4.1.5 User-Defined References
Static Semantics
Given a discriminated
type T, the following type-related operational aspect may be specified:
Implicit_Dereference
This aspect is specified by a
name
that denotes an access discriminant declared for the type
T.
A (view of a) type with a specified Implicit_Dereference
aspect is a
reference type.
A
reference
object is an object of a reference type.
The
discriminant named by the Implicit_Dereference aspect is the
reference
discriminant of the reference type or reference object.
A
generalized_reference
is a
name
that identifies a reference object, and denotes the object or subprogram
designated by the reference discriminant of the reference object.
Syntax
generalized_reference ::= reference_object_name
Name Resolution Rules
Static Semantics
The Implicit_Dereference aspect is nonoverridable
(see
13.1.1).
A
generalized_reference
denotes a view equivalent to that of a dereference of the reference discriminant
of the reference object.
Given a reference type
T, the Implicit_Dereference
aspect is inherited by descendants of type
T if not overridden
(which is only permitted if confirming). If a descendant type constrains
the value of the reference discriminant of
T by a new discriminant,
that new discriminant is the reference discriminant of the descendant.
If the descendant type constrains the value of the reference discriminant
of
T by an
expression
other than the
name
of a new discriminant, a
generalized_reference
that identifies an object of the descendant type denotes the object or
subprogram designated by the value of this constraining expression.
Dynamic Semantics
The evaluation of a
generalized_reference
consists of the evaluation of the
reference_object_name
and a determination of the object or subprogram designated by the reference
discriminant of the named reference object.
A
check is made that the value of the reference discriminant is not the
null access value.
Constraint_Error is raised if
this check fails. The
generalized_reference
denotes the object or subprogram designated by the value of the reference
discriminant of the named reference object.
Examples
Examples of the
specification and use of generalized references:
type Barrel is tagged ... -- holds objects of type Element
type Ref_Element(Data : access Element) is limited private
with Implicit_Dereference => Data;
-- This Ref_Element type is a "reference" type.
-- "Data" is its reference discriminant.
function Find (B : aliased in out Barrel; Key : String)
return Ref_Element;
-- Returns a reference to an element of a barrel.
B: aliased Barrel;
...
Find (B, "grape") := Element'(...); -- Assign through a reference.
-- This is equivalent to:
Find (B, "grape").Data.all := Element'(...);
Usage
For most uses, and in particular for types used with
user-defined indexing (see
4.1.6), reference
types should be limited types. Doing so helps avoid ambiguities that
otherwise can arise. Ambiguities are possible because a
name
that can be interpreted as a
generalized_reference
can also be interpreted in the usual way (that is, as a
name
denoting an object of the reference type). For example, if X and Y are
objects of a reference type T1 that has an "
access T2"
reference discriminant, then the expression X = Y would be ambiguous
if equality operators for both T1 and T2 are directly visible. See the
example below where T1 is Bad_Ref and T2 is Barrel. Such ambiguities
can especially complicate the use of user-defined indexing.
type Bad_Ref (D : access Barrel) is null record
with Implicit_Dereference => D;
function Create_Ref (B : aliased in out Barrel) return Bad_Ref;
X, Y : Bad_Ref := Create_Ref (B);
...
if X = Y then -- Ambiguous, "=" can be for type Bad_Ref or type Barrel.
...
Ada 2005 and 2012 Editions sponsored in part by Ada-Europe
