/usr/share/ada/adainclude/gnatcoll/gnatcoll-refcount.ads is in libgnatcoll1.6-dev 1.6gpl2014-6.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 | ------------------------------------------------------------------------------
-- G N A T C O L L --
-- --
-- Copyright (C) 2010-2014, AdaCore --
-- --
-- This library is free software; you can redistribute it and/or modify it --
-- under terms of the GNU General Public License as published by the Free --
-- Software Foundation; either version 3, 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 MERCHAN- --
-- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. --
-- --
-- --
-- --
-- --
-- --
-- You should have received a copy of the GNU General Public License and --
-- a copy of the GCC Runtime Library Exception along with this program; --
-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
-- <http://www.gnu.org/licenses/>. --
-- --
------------------------------------------------------------------------------
-- This package provides support for reference counting.
-- A Smart_Pointer plays the role of an access type (although it is not an
-- access type), and keeps a reference to the designated entity. When a smart
-- pointer goes out of scope, the designated entity's reference count is
-- automatically decremented.
-- When the reference count reaches 0, the corresponding entity is freed.
pragma Ada_05;
with Interfaces;
private with Ada.Finalization;
package GNATCOLL.Refcount is
type Refcounted is abstract tagged private;
type Refcounted_Access is access all Refcounted'Class;
-- The common ancestor for all refcounted types.
-- This ancestor adds a refcount field, which keeps track of how many
-- references exist to a particular instance of Refcounted.
--
-- The refcounting is type safe (that is you can use the smart pointer from
-- multiple tasks concurrently, and the refcounting will always be
-- accurate). But the task-safety of Refcounted itself depends on your
-- application.
procedure Free (Self : in out Refcounted) is null;
-- Free the memory associated with Self, when Self is no longer referenced.
package Sync_Counters is
function Sync_Add_And_Fetch
(Ptr : access Interfaces.Integer_32;
Value : Interfaces.Integer_32) return Interfaces.Integer_32;
-- Increment Ptr by Value. This is task safe (either using a lock or
-- intrinsic atomic operations). Returns the new value (as set, it
-- might already have been changed by another by the time this function
-- returns.
end Sync_Counters;
--------------------
-- Smart_Pointers --
--------------------
generic
type Encapsulated is abstract new Refcounted with private;
package Smart_Pointers is
type Encapsulated_Access is access all Encapsulated'Class;
type Ref is tagged private;
Null_Ref : constant Ref;
procedure Set (Self : in out Ref; Data : Encapsulated'Class);
procedure Set (Self : in out Ref; Data : access Encapsulated'Class);
-- Replace the current contents of Self.
-- Data is adopted by the smart pointer, and should no longer be
-- referenced directly elsewhere. The reference count of Data is
-- incremented by 1.
-- Typical code looks like:
-- Tmp := new Encapsulated;
-- Set (Ptr, Tmp);
-- (You can't do
-- Set (Ptr, new Encapsulated);
-- for visibility reasons)
function Get (P : Ref) return Encapsulated_Access;
pragma Inline (Get);
-- Return a pointer the data pointed to by P.
-- We return an access type for efficiency reasons. However, the
-- returned value must not be freed by the caller.
overriding function "=" (P1, P2 : Ref) return Boolean;
-- Whether the two pointers point to the same data
function Get_Refcount (Self : Ref) return Natural;
-- Return the current reference count.
-- This is mostly intended for debug purposes.
private
type Ref is new Ada.Finalization.Controlled with record
Data : Refcounted_Access;
end record;
overriding procedure Finalize (P : in out Ref);
overriding procedure Adjust (P : in out Ref);
-- Take care of reference counting
Null_Ref : constant Ref :=
(Ada.Finalization.Controlled with Data => null);
end Smart_Pointers;
private
type Refcounted is abstract tagged record
Refcount : aliased Interfaces.Integer_32 := 0;
end record;
-- This requires, as a result, that all refcounted types also be tagged
-- types (thus adding the size of a tag and the size of an integer to each
-- instance). This approach was chosen over storing the refcounting
-- independently of the refcounted type. The chosen approach provides a
-- tighter integration between the two.
end GNATCOLL.Refcount;
|