4.1.5 User-Defined References
Static Semantics
{
AI05-0139-2}
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.
Aspect Description for Implicit_Dereference:
Mechanism for user-defined implicit .all.
{
AI05-0139-2}
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.]
Term entry: reference type β
type that has user-defined behavior for β.allβ, defined by
the Implicit_Dereference aspect
Syntax
Name Resolution Rules
Static Semantics
Reason: This ensures that all descendants
of a reference type have the same reference discriminant. This prevents
generic contract problems with formal derived types.
{
AI05-0139-2}
{
AI12-0203-1}
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
{
AI05-0139-2}
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
{
AI12-0429-1}
Examples of the specification and use of generalized references:{
AI05-0268-1}
type Barrel
is tagged ... --
holds objects of type Element{
AI05-0139-2}
{
AI05-0299-1}
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.{
AI05-0139-2}
{
AI05-0268-1}
function Find (B :
aliased in out Barrel; Key : String)
return Ref_Element;
--
Returns a reference to an element of a barrel.Usage
{
AI22-0092-1}
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, "=" could be for type Bad_Ref or type Barrel.
...
Extensions to Ada 2005
Incompatibilities With Ada 2012
{
AI12-0138-1}
Corrigendum: Defined Implicit_Dereference
to be nonoveridable, which makes redefinitions and hiding of the aspect
illegal. It's possible that some program could violate one of these new
restrictions, but this is not very likely as reference types are not
likely to be used in a hierarchy.
Ada 2005 and 2012 Editions sponsored in part by Ada-Europe
