Two class-wide operands, but only one controlling

Two class-wide operands, but only one controlling

[Victor Porton]

I want something like a procedure with two class-wide operands,
(of two different types) but only one of these controlling.

The solution I found is introducing new tagged record
types which would refer to these two types and passing both
operands as one operand in such the record. Other solutions?

Re: Two class-wide operands, but only one controlling

[Pascal Obry]

porton@ex-code.com (Victor Porton) writes:

> I want something like a procedure with two class-wide operands,
> (of two different types) but only one of these controlling.
> 
> The solution I found is introducing new tagged record
> types which would refer to these two types and passing both
> operands as one operand in such the record. Other solutions?

Declare the second one as a class-wide ('Class) parameter.

Pascal.

-- 

--|------------------------------------------------------
--| Pascal Obry                           Team-Ada Member
--| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
--|------------------------------------------------------
--|         http://perso.wanadoo.fr/pascal.obry
--| "The best way to travel is by means of imagination"
--|
--| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595

Re: Two class-wide operands, but only one controlling

[Victor Porton]

In article <ubs4gvzea.fsf@wanadoo.fr>,
	Pascal Obry <p.obry@wanadoo.fr> writes:
> porton@ex-code.com (Victor Porton) writes:
> 
>> I want something like a procedure with two class-wide operands,
>> (of two different types) but only one of these controlling.
>> 
>> The solution I found is introducing new tagged record
>> types which would refer to these two types and passing both
>> operands as one operand in such the record. Other solutions?
> 
> Declare the second one as a class-wide ('Class) parameter.

What?! It is clearly stated that I want _both_ of them
class wide...

Re: Two class-wide operands, but only one controlling

[Samuel Tardieu]

>>>>> "Victor" == Victor Porton <porton@ex-code.com> writes:

Victor> In article <ubs4gvzea.fsf@wanadoo.fr>,
Victor> 	Pascal Obry <p.obry@wanadoo.fr> writes:
>> porton@ex-code.com (Victor Porton) writes:
>>
>>> I want something like a procedure with two class-wide operands,
>>> (of two different types) but only one of these controlling.
>>>
>>> The solution I found is introducing new tagged record types which
>>> would refer to these two types and passing both operands as one
>>> operand in such the record. Other solutions?
>>
>> Declare the second one as a class-wide ('Class) parameter.

Victor> What?! It is clearly stated that I want _both_ of them class
Victor> wide...

I think you are confusing actual (in the call) and formal (in the
declaration) parameters. Pascal proposes that you use a first
non-class-wide formal parameter and a second class-wide formal
parameter.

The actual parameter of a class-wide formal parameter cannot be a
controlling operand.

  Sam
-- 
Samuel Tardieu -- sam@rfc1149.net -- http://www.rfc1149.net/sam

Re: Two class-wide operands, but only one controlling

[Victor Porton]

In article <877kf34a3t.fsf@inf.enst.fr>,
	Samuel Tardieu <sam@rfc1149.net> writes:
>>>>>> "Victor" == Victor Porton <porton@ex-code.com> writes:
> 
> Victor> In article <ubs4gvzea.fsf@wanadoo.fr>,
> Victor> 	Pascal Obry <p.obry@wanadoo.fr> writes:
>>> porton@ex-code.com (Victor Porton) writes:
>>>
>>>> I want something like a procedure with two class-wide operands,
>>>> (of two different types) but only one of these controlling.
>>>>
>>>> The solution I found is introducing new tagged record types which
>>>> would refer to these two types and passing both operands as one
>>>> operand in such the record. Other solutions?
>>>
>>> Declare the second one as a class-wide ('Class) parameter.
> 
> Victor> What?! It is clearly stated that I want _both_ of them class
> Victor> wide...
> 
> I think you are confusing actual (in the call) and formal (in the
> declaration) parameters. Pascal proposes that you use a first
> non-class-wide formal parameter and a second class-wide formal
> parameter.

Not what I need. basically I have a container and an iterator.
Both a derived (in my case I need this) from abstract container
and abstract iterator. I need procedure like:

procedure Next
  (C: Abstract_Container'Class; I: in out Abstract_Iterator'Class);
  
but this is an error as we have two controlling operands of
different types :-( I cannot make one of these non class-wide
as both a abstract.

It was simple in C++. Ada has disadvantages...

> The actual parameter of a class-wide formal parameter cannot be a
> controlling operand.

Samuel, di you meant vice versa?

Re: Two class-wide operands, but only one controlling

[Pascal Obry]

porton@ex-code.com (Victor Porton) writes:

> Not what I need. basically I have a container and an iterator.
> Both a derived (in my case I need this) from abstract container
> and abstract iterator. I need procedure like:
> 
> procedure Next
>   (C: Abstract_Container'Class; I: in out Abstract_Iterator'Class);
>   
> but this is an error as we have two controlling operands of
> different types :-( 

Certainly not. 'Class formal parameters are not controlling operands, your
Next procedure above is perfectly legal.

> It was simple in C++. Ada has disadvantages...

No, you misunderstood Ada :)

> > The actual parameter of a class-wide formal parameter cannot be a
> > controlling operand.
> 
> Samuel, di you meant vice versa?

No, we have be 2 of us saying the same thing but you did not listen :)

Pascal.

-- 

--|------------------------------------------------------
--| Pascal Obry                           Team-Ada Member
--| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
--|------------------------------------------------------
--|         http://perso.wanadoo.fr/pascal.obry
--| "The best way to travel is by means of imagination"
--|
--| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595

Re: Two class-wide operands, but only one controlling

[Matthew Heaney]

porton@ex-code.com (Victor Porton) wrote in message news:<3ddfa8b8$0$304$bed64819@news.gradwell.net>...
> I want something like a procedure with two class-wide operands,
> (of two different types) but only one of these controlling.
> 
> The solution I found is introducing new tagged record
> types which would refer to these two types and passing both
> operands as one operand in such the record. Other solutions?

No, you don't need two separate types.  Just declare the second
parameter as type T'Class, e.g.

   type T is tagged ...;

   procedure Op (O1 : T; O2 : T'Class);

Now procedure Op only dispatches according to the tag of O1.

If you want two separate types, then just do this:

   procedure Op (O1 : T; O2 : T2'Class);

Re: Two class-wide operands, but only one controlling

[Matthew Heaney]

porton@ex-code.com (Victor Porton) wrote in message news:<3de0b9be$0$304$bed64819@news.gradwell.net>...
> 
> Not what I need. basically I have a container and an iterator.
> Both a derived (in my case I need this) from abstract container
> and abstract iterator. I need procedure like:
> 
> procedure Next
>   (C: Abstract_Container'Class; I: in out Abstract_Iterator'Class);
>   
> but this is an error as we have two controlling operands of
> different types :-( I cannot make one of these non class-wide
> as both a abstract.
> 
> It was simple in C++. Ada has disadvantages...

Whatever you can do in C++, you can also do in Ada.

Post the C++ code (or just email it do me), and we'll see if we can't
figure out what the real problem is.

Re: Two class-wide operands, but only one controlling

[Matthew Heaney]

porton@ex-code.com (Victor Porton) wrote in message news:<3de0b9be$0$304$bed64819@news.gradwell.net>...
> 
> Not what I need. basically I have a container and an iterator.
> Both a derived (in my case I need this) from abstract container
> and abstract iterator. I need procedure like:
> 
> procedure Next
>   (C: Abstract_Container'Class; I: in out Abstract_Iterator'Class);
>   
> but this is an error as we have two controlling operands of
> different types :-( I cannot make one of these non class-wide
> as both a abstract.
> 
> It was simple in C++. Ada has disadvantages...

A virtual function can only be a class member function, which means it
can be virtual for only one class.

Either you have this:

class Container
{
public:
   class Iterator { ... };

   virtual void next(Iterator&) const = 0;
...
};

Or you have this:

class Container
{
public:
   class Iterator 
   {
   public:
      virtual void next(const Container&) = 0;
      ...
   };
...
};


Both of which have a trivial conversion to Ada95.  So what is the
problem, exactly?