luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2024-11-15 05:46:15 +01:00
Code Issues Packages Projects Releases Wiki Activity
51e6e4fc2f
glib/glib/grcbox.h

90 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>
glib_typeof: Move definition to its own header It is cleaner to define glib_typeof() in a header included after gversionmacros.h so we can use GLIB_VERSION_MIN_REQUIRED directly instead of doing it everywhere glib_typeof() is used.
2021-02-26 21:15:57 +01:00
#include <glib/glib-typeof.h>
glib/gmacros.h: Move `<type_traits>` include to consumers When included inside an `extern "C"` block, this causes build failures that look something like: /usr/include/c++/10/type_traits:2930:3: error: template with C linkage 2930 | template<typename _Fn, typename... _Args> | ^~~~~~~~ ../../disas/arm-a64.cc:20:1: note: ‘extern "C"’ linkage started here 20 | extern "C" { | ^~~~~~~~~~ Commit 4273c43902a7e6b22cea0041436ee5715c93be76 made this opt in for projects which are defining `GLIB_VERSION_MIN_REQUIRED`, but the include of `<type_traits>` via `gmacros.h` was not included in this. If we move the include out to the places where `glib_typeof` is called, we can make it covered by this macro too, and save a few consumers from FTBFSing. That also means that, if you don't want to fix your use of the headers, and as long as this version is sufficient for you, a quick workaround is to define `GLIB_VERSION_MIN_REQUIRED` to `GLIB_VERSION_2_66` or lower. Suggested by Simon McVittie. Alternative to: https://gitlab.gnome.org/GNOME/glib/-/merge_requests/1935 Fixes: https://gitlab.gnome.org/GNOME/glib/-/issues/2331
2021-02-24 16:11:42 +01: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
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
glib_typeof: Move definition to its own header It is cleaner to define glib_typeof() in a header included after gversionmacros.h so we can use GLIB_VERSION_MIN_REQUIRED directly instead of doing it everywhere glib_typeof() is used.
2021-02-26 21:15:57 +01:00
#if defined(glib_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 */
Replace __typeof__ with glib_typeof macro g_has_typeof macro is wrongly in the public g_ namespace, internaly symbols are usually in the glib_ namespace. This will also allow to define glib_typeof differently on non-GNUC compilers (e.g. c++11 decltype).
2020-07-25 21:05:51 +02:00
#define g_rc_box_acquire(mem_block) \
((glib_typeof (mem_block)) (g_rc_box_acquire) (mem_block))
#define g_atomic_rc_box_acquire(mem_block) \
((glib_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 */
Replace __typeof__ with glib_typeof macro g_has_typeof macro is wrongly in the public g_ namespace, internaly symbols are usually in the glib_ namespace. This will also allow to define glib_typeof differently on non-GNUC compilers (e.g. c++11 decltype).
2020-07-25 21:05:51 +02:00
#define g_rc_box_dup(block_size, mem_block) \
((glib_typeof (mem_block)) (g_rc_box_dup) (block_size, mem_block))
#define g_atomic_rc_box_dup(block_size, mem_block) \
((glib_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