luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2024-12-28 00:16:15 +01:00
Code Issues Packages Projects Releases Wiki Activity
e446c3487b
glib/glib/grcbox.h

89 lines
3.7 KiB
C
Raw Normal View History

Add refcounted data It is useful to provide a "reference counted allocation" API that can add reference counting semantics to any memory allocation. This allows turning data structures that usually are placed on the stack into memory that can be placed on the heap without: - adding a public reference count field - implementing copy/free semantics This mechanism is similar to Rust's Rc<Box<T>> combination of traits, and uses a Valgrind-friendly overallocation mechanism to store the reference count into a private data segment, like we do with GObject's private instance data.
2018-06-10 13:20:34 +02:00
/* grcbox.h: Reference counted data
*
* Copyright 2018 Emmanuele Bassi
*
* 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/>.
*/
#pragma once
#if !defined (__GLIB_H_INSIDE__) && !defined (GLIB_COMPILATION)
#error "Only <glib.h> can be included directly."
#endif
#include <glib/gmem.h>
G_BEGIN_DECLS
GLIB_AVAILABLE_IN_2_58
Rename g_arc_box to g_atomic_rc_box Makes the API more self-explanatory.
2018-07-03 16:23:34 +02:00
gpointer g_rc_box_alloc (gsize block_size) G_GNUC_MALLOC G_GNUC_ALLOC_SIZE(1);
Add refcounted data It is useful to provide a "reference counted allocation" API that can add reference counting semantics to any memory allocation. This allows turning data structures that usually are placed on the stack into memory that can be placed on the heap without: - adding a public reference count field - implementing copy/free semantics This mechanism is similar to Rust's Rc<Box<T>> combination of traits, and uses a Valgrind-friendly overallocation mechanism to store the reference count into a private data segment, like we do with GObject's private instance data.
2018-06-10 13:20:34 +02:00
GLIB_AVAILABLE_IN_2_58
Rename g_arc_box to g_atomic_rc_box Makes the API more self-explanatory.
2018-07-03 16:23:34 +02:00
gpointer g_rc_box_alloc0 (gsize block_size) G_GNUC_MALLOC G_GNUC_ALLOC_SIZE(1);
Add refcounted data It is useful to provide a "reference counted allocation" API that can add reference counting semantics to any memory allocation. This allows turning data structures that usually are placed on the stack into memory that can be placed on the heap without: - adding a public reference count field - implementing copy/free semantics This mechanism is similar to Rust's Rc<Box<T>> combination of traits, and uses a Valgrind-friendly overallocation mechanism to store the reference count into a private data segment, like we do with GObject's private instance data.
2018-06-10 13:20:34 +02:00
GLIB_AVAILABLE_IN_2_58
Rename g_arc_box to g_atomic_rc_box Makes the API more self-explanatory.
2018-07-03 16:23:34 +02:00
gpointer g_rc_box_dup (gsize block_size,
glib: Drop G_GNUC_MALLOC usage from various allocation functions These are our most critically incorrect uses of G_GNUC_MALLOC. See the previous commit for details. Signed-off-by: Philip Withnall <withnall@endlessm.com> https://gitlab.gnome.org/GNOME/glib/issues/1465
2018-08-22 12:09:01 +02:00
gconstpointer mem_block) G_GNUC_ALLOC_SIZE(1);
Add refcounted data It is useful to provide a "reference counted allocation" API that can add reference counting semantics to any memory allocation. This allows turning data structures that usually are placed on the stack into memory that can be placed on the heap without: - adding a public reference count field - implementing copy/free semantics This mechanism is similar to Rust's Rc<Box<T>> combination of traits, and uses a Valgrind-friendly overallocation mechanism to store the reference count into a private data segment, like we do with GObject's private instance data.
2018-06-10 13:20:34 +02:00
GLIB_AVAILABLE_IN_2_58
Rename g_arc_box to g_atomic_rc_box Makes the API more self-explanatory.
2018-07-03 16:23:34 +02:00
gpointer g_rc_box_acquire (gpointer mem_block);
Add refcounted data It is useful to provide a "reference counted allocation" API that can add reference counting semantics to any memory allocation. This allows turning data structures that usually are placed on the stack into memory that can be placed on the heap without: - adding a public reference count field - implementing copy/free semantics This mechanism is similar to Rust's Rc<Box<T>> combination of traits, and uses a Valgrind-friendly overallocation mechanism to store the reference count into a private data segment, like we do with GObject's private instance data.
2018-06-10 13:20:34 +02:00
GLIB_AVAILABLE_IN_2_58
Rename g_arc_box to g_atomic_rc_box Makes the API more self-explanatory.
2018-07-03 16:23:34 +02:00
void g_rc_box_release (gpointer mem_block);
Add refcounted data It is useful to provide a "reference counted allocation" API that can add reference counting semantics to any memory allocation. This allows turning data structures that usually are placed on the stack into memory that can be placed on the heap without: - adding a public reference count field - implementing copy/free semantics This mechanism is similar to Rust's Rc<Box<T>> combination of traits, and uses a Valgrind-friendly overallocation mechanism to store the reference count into a private data segment, like we do with GObject's private instance data.
2018-06-10 13:20:34 +02:00
GLIB_AVAILABLE_IN_2_58
Rename g_arc_box to g_atomic_rc_box Makes the API more self-explanatory.
2018-07-03 16:23:34 +02:00
void g_rc_box_release_full (gpointer mem_block,
GDestroyNotify clear_func);
Add refcounted data It is useful to provide a "reference counted allocation" API that can add reference counting semantics to any memory allocation. This allows turning data structures that usually are placed on the stack into memory that can be placed on the heap without: - adding a public reference count field - implementing copy/free semantics This mechanism is similar to Rust's Rc<Box<T>> combination of traits, and uses a Valgrind-friendly overallocation mechanism to store the reference count into a private data segment, like we do with GObject's private instance data.
2018-06-10 13:20:34 +02:00
Add size accessor to RcBox and ArcBox It may be useful to know how big a reference counted allocation is outside of internal checks.
2018-06-12 14:56:29 +02:00
GLIB_AVAILABLE_IN_2_58
Rename g_arc_box to g_atomic_rc_box Makes the API more self-explanatory.
2018-07-03 16:23:34 +02:00
gsize g_rc_box_get_size (gpointer mem_block);
Add size accessor to RcBox and ArcBox It may be useful to know how big a reference counted allocation is outside of internal checks.
2018-06-12 14:56:29 +02:00
Add atomically refcounted data GArcBox is the atomic reference counting version of GRcBox. Unlike GRcBox, the reference acquisition and release on GArcBox are guaranteed to be atomic, and thus they can be performed from different threads. This is similar to Rust's Arc<Box<T>> combination of traits.
2018-06-11 12:52:54 +02:00
GLIB_AVAILABLE_IN_2_58
Rename g_arc_box to g_atomic_rc_box Makes the API more self-explanatory.
2018-07-03 16:23:34 +02:00
gpointer g_atomic_rc_box_alloc (gsize block_size) G_GNUC_MALLOC G_GNUC_ALLOC_SIZE(1);
Add atomically refcounted data GArcBox is the atomic reference counting version of GRcBox. Unlike GRcBox, the reference acquisition and release on GArcBox are guaranteed to be atomic, and thus they can be performed from different threads. This is similar to Rust's Arc<Box<T>> combination of traits.
2018-06-11 12:52:54 +02:00
GLIB_AVAILABLE_IN_2_58
Rename g_arc_box to g_atomic_rc_box Makes the API more self-explanatory.
2018-07-03 16:23:34 +02:00
gpointer g_atomic_rc_box_alloc0 (gsize block_size) G_GNUC_MALLOC G_GNUC_ALLOC_SIZE(1);
Add atomically refcounted data GArcBox is the atomic reference counting version of GRcBox. Unlike GRcBox, the reference acquisition and release on GArcBox are guaranteed to be atomic, and thus they can be performed from different threads. This is similar to Rust's Arc<Box<T>> combination of traits.
2018-06-11 12:52:54 +02:00
GLIB_AVAILABLE_IN_2_58
Rename g_arc_box to g_atomic_rc_box Makes the API more self-explanatory.
2018-07-03 16:23:34 +02:00
gpointer g_atomic_rc_box_dup (gsize block_size,
glib: Drop G_GNUC_MALLOC usage from various allocation functions These are our most critically incorrect uses of G_GNUC_MALLOC. See the previous commit for details. Signed-off-by: Philip Withnall <withnall@endlessm.com> https://gitlab.gnome.org/GNOME/glib/issues/1465
2018-08-22 12:09:01 +02:00
gconstpointer mem_block) G_GNUC_ALLOC_SIZE(1);
Add atomically refcounted data GArcBox is the atomic reference counting version of GRcBox. Unlike GRcBox, the reference acquisition and release on GArcBox are guaranteed to be atomic, and thus they can be performed from different threads. This is similar to Rust's Arc<Box<T>> combination of traits.
2018-06-11 12:52:54 +02:00
GLIB_AVAILABLE_IN_2_58
Rename g_arc_box to g_atomic_rc_box Makes the API more self-explanatory.
2018-07-03 16:23:34 +02:00
gpointer g_atomic_rc_box_acquire (gpointer mem_block);
Add atomically refcounted data GArcBox is the atomic reference counting version of GRcBox. Unlike GRcBox, the reference acquisition and release on GArcBox are guaranteed to be atomic, and thus they can be performed from different threads. This is similar to Rust's Arc<Box<T>> combination of traits.
2018-06-11 12:52:54 +02:00
GLIB_AVAILABLE_IN_2_58
Rename g_arc_box to g_atomic_rc_box Makes the API more self-explanatory.
2018-07-03 16:23:34 +02:00
void g_atomic_rc_box_release (gpointer mem_block);
Add atomically refcounted data GArcBox is the atomic reference counting version of GRcBox. Unlike GRcBox, the reference acquisition and release on GArcBox are guaranteed to be atomic, and thus they can be performed from different threads. This is similar to Rust's Arc<Box<T>> combination of traits.
2018-06-11 12:52:54 +02:00
GLIB_AVAILABLE_IN_2_58
Rename g_arc_box to g_atomic_rc_box Makes the API more self-explanatory.
2018-07-03 16:23:34 +02:00
void g_atomic_rc_box_release_full (gpointer mem_block,
GDestroyNotify clear_func);
Add atomically refcounted data GArcBox is the atomic reference counting version of GRcBox. Unlike GRcBox, the reference acquisition and release on GArcBox are guaranteed to be atomic, and thus they can be performed from different threads. This is similar to Rust's Arc<Box<T>> combination of traits.
2018-06-11 12:52:54 +02:00
Add size accessor to RcBox and ArcBox It may be useful to know how big a reference counted allocation is outside of internal checks.
2018-06-12 14:56:29 +02:00
GLIB_AVAILABLE_IN_2_58
Rename g_arc_box to g_atomic_rc_box Makes the API more self-explanatory.
2018-07-03 16:23:34 +02:00
gsize g_atomic_rc_box_get_size (gpointer mem_block);
Add size accessor to RcBox and ArcBox It may be useful to know how big a reference counted allocation is outside of internal checks.
2018-06-12 14:56:29 +02:00
Add refcounted data It is useful to provide a "reference counted allocation" API that can add reference counting semantics to any memory allocation. This allows turning data structures that usually are placed on the stack into memory that can be placed on the heap without: - adding a public reference count field - implementing copy/free semantics This mechanism is similar to Rust's Rc<Box<T>> combination of traits, and uses a Valgrind-friendly overallocation mechanism to store the reference count into a private data segment, like we do with GObject's private instance data.
2018-06-10 13:20:34 +02:00
#define g_rc_box_new(type) \
((type *) g_rc_box_alloc (sizeof (type)))
#define g_rc_box_new0(type) \
((type *) g_rc_box_alloc0 (sizeof (type)))
Rename g_arc_box to g_atomic_rc_box Makes the API more self-explanatory.
2018-07-03 16:23:34 +02:00
#define g_atomic_rc_box_new(type) \
((type *) g_atomic_rc_box_alloc (sizeof (type)))
#define g_atomic_rc_box_new0(type) \
((type *) g_atomic_rc_box_alloc0 (sizeof (type)))
Add refcounted data It is useful to provide a "reference counted allocation" API that can add reference counting semantics to any memory allocation. This allows turning data structures that usually are placed on the stack into memory that can be placed on the heap without: - adding a public reference count field - implementing copy/free semantics This mechanism is similar to Rust's Rc<Box<T>> combination of traits, and uses a Valgrind-friendly overallocation mechanism to store the reference count into a private data segment, like we do with GObject's private instance data.
2018-06-10 13:20:34 +02:00
gmacros: Add new private g_has_typeof to abstract __typeof__ checks We have this same check in a few places now, and we might as well abstract it out. Fixes #1440.
2018-07-11 16:09:29 +02:00
#ifdef g_has_typeof
Add refcounted data It is useful to provide a "reference counted allocation" API that can add reference counting semantics to any memory allocation. This allows turning data structures that usually are placed on the stack into memory that can be placed on the heap without: - adding a public reference count field - implementing copy/free semantics This mechanism is similar to Rust's Rc<Box<T>> combination of traits, and uses a Valgrind-friendly overallocation mechanism to store the reference count into a private data segment, like we do with GObject's private instance data.
2018-06-10 13:20:34 +02:00
/* Type check to avoid assigning references to different types */
Add atomically refcounted data GArcBox is the atomic reference counting version of GRcBox. Unlike GRcBox, the reference acquisition and release on GArcBox are guaranteed to be atomic, and thus they can be performed from different threads. This is similar to Rust's Arc<Box<T>> combination of traits.
2018-06-11 12:52:54 +02:00
# define g_rc_box_acquire(mem_block) \
((__typeof__(mem_block)) (g_rc_box_acquire) (mem_block))
Rename g_arc_box to g_atomic_rc_box Makes the API more self-explanatory.
2018-07-03 16:23:34 +02:00
# define g_atomic_rc_box_acquire(mem_block) \
((__typeof__(mem_block)) (g_atomic_rc_box_acquire) (mem_block))
Add atomically refcounted data GArcBox is the atomic reference counting version of GRcBox. Unlike GRcBox, the reference acquisition and release on GArcBox are guaranteed to be atomic, and thus they can be performed from different threads. This is similar to Rust's Arc<Box<T>> combination of traits.
2018-06-11 12:52:54 +02:00
Add refcounted data It is useful to provide a "reference counted allocation" API that can add reference counting semantics to any memory allocation. This allows turning data structures that usually are placed on the stack into memory that can be placed on the heap without: - adding a public reference count field - implementing copy/free semantics This mechanism is similar to Rust's Rc<Box<T>> combination of traits, and uses a Valgrind-friendly overallocation mechanism to store the reference count into a private data segment, like we do with GObject's private instance data.
2018-06-10 13:20:34 +02:00
/* Type check to avoid duplicating data to different types */
Make g_rc_box_dup()/g_arc_box_dup() more generic It's more useful to have a dup() function that copies any blob of memory into a reference counted allocation, than to have a dup() that only copies a reference counted allocation.
2018-06-11 18:14:12 +02:00
# define g_rc_box_dup(block_size,mem_block) \
((__typeof__(mem_block)) (g_rc_box_dup) (block_size,mem_block))
Rename g_arc_box to g_atomic_rc_box Makes the API more self-explanatory.
2018-07-03 16:23:34 +02:00
# define g_atomic_rc_box_dup(block_size,mem_block) \
((__typeof__(mem_block)) (g_atomic_rc_box_dup) (block_size,mem_block))
Add refcounted data It is useful to provide a "reference counted allocation" API that can add reference counting semantics to any memory allocation. This allows turning data structures that usually are placed on the stack into memory that can be placed on the heap without: - adding a public reference count field - implementing copy/free semantics This mechanism is similar to Rust's Rc<Box<T>> combination of traits, and uses a Valgrind-friendly overallocation mechanism to store the reference count into a private data segment, like we do with GObject's private instance data.
2018-06-10 13:20:34 +02:00
#endif
G_END_DECLS
Reference in New Issue Copy Permalink