Re: Limited use for limited with?

["Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>]

On Wed, 29 Sep 2010 13:51:53 -0700 (PDT), Maciej Sobczak wrote:

> On 29 Wrz, 15:41, "Dmitry A. Kazakov" <mail...@dmitry-kazakov.de>
> wrote:
> 
>>> This would create circular dependency between Object and Registry's
>>> internals.
>>
>> You add one derived type to either of the hierarchies and that breaks the
>> dependency. You have to with or without access types.
> 
> Not at all. In my design Object knows nothing about registry. There is
> no such dependency and therefore it does not have to be broken.
> You have introduced this dependency, but this is one of the many
> reasons why I don't like your solution.

I did not. You have to pass an object or its pointer to the registry, or a
registry to the object. It is no matter, the operation has two arguments.
The dependency is here.

>> Object would call a class-wide operation of Registry from its Finalize.
> 
> This assumes that Registry is object-oriented and that all registries
> have some common interface. I don't want this assumption, it does not
> reflect any system requirement.

It is not an assumption. All registries are capable to maintain objects.
The set of registry types shares this property, even if you don't introduce
this set as a class, which would be an unwise decision, the class is here.

>>> I don't control the concrete
>>> implementation - in particular I don't implement the factory
>>> (constructor function).
>>
>> You declare the factory function abstract to be implemented by derived
>> types.
> 
> And how can I enforce that user will properly use the registry from
> the constructor?

By hiding other ways to construct the parent type. If the object is
declared with (<>) discriminants and its full view is hidden you have to
use the construction function in the aggregate that creates the object.

>>> The solution that you propose is not only very complex,
>>
>> I don't see how removing a type could add complexity.
> 
> In order to "remove a type" you have introduced:
> - factory functions, perhaps abstract

I don't expose object components anyway. It is a good style to have
components private. If Initialize does not do the job, factory function is
the only choice, because, unfortunately, Ada does not have proper
constructors with parameters.

> - Controlled with Finalized

Same as above. Non-controlled tagged types make no sense, because, again,
Ada lacks constructors and destructors.

> - circular dependencies between Object and Registry (ironically, you
> have then proposed to introduce *another derived type* to break that
> dependency - does it still count as "removing a type"?)

The dependency exists anyway.

[ And it is not circular. The relation "there exists an operation with
arguments of both types" is symmetric. ]

> - common tagged root for all registries (this seems to be also an
> additional type)

A big advantage, because later I might wish to write some class-wide
operations dealing with any registry. It happened to me so many times, that
I practically always use controlled bases.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de