Assigning a "subclass" instance to a "superclass" variable

Assigning a "subclass" instance to a "superclass" variable

[deuteros]

I'm still trying to understand how Ada does object orientation. In Java I could
do this: 

Class Animal
{
  String color;

  public Animal(String color)
  {
    	this.color = color;
  }
}

Class Dog extends Animal
{
  public Dog(String color)
  {
    	super(color);
  }
}

So in Ada I'm trying to achieve something similar with my Statement
package: 

package Statements is

   type Statement is abstract tagged
      record
         tokens : Vector;
         executedtokens : Vector;
      end record;
   
   type Statement_Access is access all Statement'Class;
   
   function execute(skip: in Boolean; S: in Statement) return Integer is abstract;

end Statements;

So when I create a child of Statement, how to I set up the .ads file?

Re: Assigning a "subclass" instance to a "superclass" variable

[Simon Wright]

deuteros <deuteros@xrs.net> writes:

> I'm still trying to understand how Ada does object orientation. In
> Java I could do this:
[...]
> So in Ada I'm trying to achieve something similar with my Statement
> package: 
>
> package Statements is
>
>    type Statement is abstract tagged
>       record
>          tokens : Vector;
>          executedtokens : Vector;
>       end record;
>    
>    type Statement_Access is access all Statement'Class;
>    
>    function execute(skip: in Boolean; S: in Statement) return Integer is abstract;
>
> end Statements;
>
> So when I create a child of Statement, how to I set up the .ads file?

   with Statements;
   package Expressions is
      type Expression is new Statements.Statement with record
         ...
      end record;
      function Execute (Skip : Boolean; S : Expression) return Integer;
   end Expressions;

or

   package Statements.Expressions is
      type Expression is new Statement with record
         ...
      end record;
      function Execute (Skip : Boolean; S : Expression) return Integer;
   end Statements.Expressions;

The second form is good if the full declaration of Statement is in the
private part of Statements, since child packages can see the private
parts of their parents.

Re: Assigning a "subclass" instance to a "superclass" variable

[deuteros]

On Fri 06 Apr 2012 05:50:18p, Simon Wright <simon@pushface.org> wrote in
news:m2ty0wh6n9.fsf@pushface.org: 

>    with Statements;
>    package Expressions is
>       type Expression is new Statements.Statement with record
>          ...
>       end record;
>       function Execute (Skip : Boolean; S : Expression) return Integer;
>    end Expressions;
> 
> or
> 
>    package Statements.Expressions is
>       type Expression is new Statement with record
>          ...
>       end record;
>       function Execute (Skip : Boolean; S : Expression) return Integer;
>    end Statements.Expressions;
> 
> The second form is good if the full declaration of Statement is in the
> private part of Statements, since child packages can see the private
> parts of their parents.

Okay, so would I need to put tokens and executedtokens in Expression's
record as well or would it somehow inherit them from Statements? 

I want something like a constructor in my child classes:

    	function Create_Expression (tokens, executedtokens : Vector) return Expression is
    	    	E : Expression
    	begin
    	    	E.tokens := tokens;
    	    	E.executedtokens := executedtokens;
    	    	return E;
    	end Create_Expression;

Now if the Expression package must have its own tokens and executedtokens
I assume this would be the way to do it but if not then how would this
work? 

Re: Assigning a "subclass" instance to a "superclass" variable

[Simon Wright]

deuteros <deuteros@xrs.net> writes:

> On Fri 06 Apr 2012 05:50:18p, Simon Wright <simon@pushface.org> wrote in
> news:m2ty0wh6n9.fsf@pushface.org: 
>
>>    with Statements;
>>    package Expressions is
>>       type Expression is new Statements.Statement with record
>>          ...
>>       end record;
>>       function Execute (Skip : Boolean; S : Expression) return Integer;
>>    end Expressions;
>> 
>> or
>> 
>>    package Statements.Expressions is
>>       type Expression is new Statement with record
>>          ...
>>       end record;
>>       function Execute (Skip : Boolean; S : Expression) return Integer;
>>    end Statements.Expressions;
>> 
>> The second form is good if the full declaration of Statement is in
>> the private part of Statements, since child packages can see the
>> private parts of their parents.
>
> Okay, so would I need to put tokens and executedtokens in Expression's
> record as well or would it somehow inherit them from Statements?

They are inherited. See the Ada 95 Rationale:
http://www.adaic.org/resources/add_content/standards/95rat/rat95html/rat95-p1-2.html#1

Re: Assigning a "subclass" instance to a "superclass" variable

[Dmitry A. Kazakov]

On Fri, 6 Apr 2012 23:13:40 +0000 (UTC), deuteros wrote:

> I want something like a constructor in my child classes:
> 
>     	function Create_Expression (tokens, executedtokens : Vector) return Expression is
>     	    	E : Expression
>     	begin
>     	    	E.tokens := tokens;
>     	    	E.executedtokens := executedtokens;
>     	    	return E;
>     	end Create_Expression;
> 
> Now if the Expression package must have its own tokens and executedtokens
> I assume this would be the way to do it but if not then how would this
> work?

Then the parent type (Statement) should not have them in its
implementation. If children have token types of their own (a parallel types
hierarchy), you should provide an abstract interface to access
child-specific tokens. E.g.

   function Get_Token (S : Statement; Index : Token_Index_Type)
      return Token_Type'Class is abstract;

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

Re: Assigning a "subclass" instance to a "superclass" variable

[Niklas Holsti]

On 12-04-07 02:13 , deuteros wrote:
> On Fri 06 Apr 2012 05:50:18p, Simon Wright<simon@pushface.org>  wrote in
> news:m2ty0wh6n9.fsf@pushface.org:
>
>>     with Statements;
>>     package Expressions is
>>        type Expression is new Statements.Statement with record
>>           ...
>>        end record;
>>        function Execute (Skip : Boolean; S : Expression) return Integer;
>>     end Expressions;

    .. snip ..

> Okay, so would I need to put tokens and executedtokens in Expression's
> record as well or would it somehow inherit them from Statements?

They are inherited. In the form

       type Expression is new Statement with record
          ...
       end record;

the part "new Statement" brings in the components of the Statement type, 
and the part "with record ... end record" adds new components for 
Expression. These components *extend* the Statement record.

If you have a variable E : Expression, you can refer to E.tokens and 
E.executedtokens (assuming that this point in the code has visibility on 
the structure of a Statement). And of course you can refer to 
E.<component> for any <component> declared in the "with record...end 
record" (again assuming visibility).

> I want something like a constructor in my child classes:
>
>      	function Create_Expression (tokens, executedtokens : Vector) return Expression is
>      	    	E : Expression
>      	begin
>      	    	E.tokens := tokens;
>      	    	E.executedtokens := executedtokens;
>      	    	return E;
>      	end Create_Expression;

That should work. But note that Ada does not have a special sort of 
"constructor" functions, such as C++ and Java do, so the above is just 
an ordinary (primitive) function in Ada, with the same rules and syntax. 
(There have been several discussions of this topic on c.l.a in the past, 
and some think that the this is a flaw in Ada.)

-- 
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
       .      @       .

Re: Assigning a "subclass" instance to a "superclass" variable

[Georg Bauhaus]

On 06.04.12 22:49, deuteros wrote:
> I'm still trying to understand how Ada does object orientation.

Just for completeness,

type Animal is...
    .
   / \
  ´ ~ `
    |
type Dog is new Animal...

Each type declaration is typically followed by a number
of declarations of subprograms that take, or return, at least
one argument of the preceding type. These subprograms become
the primitive operations of the preceding type (its methods),
overriding operations where the parent type has the "same"
operation.

Placing the type declarations in packages at all, in nested
packages, in task bodies, in child packages, declaring
them local to a procedure, etc ... is the programmer's choice:
doing any of these will establish corresponding visibility
of the types. So the key question might be where you want
the types visible.

> So in Ada I'm trying to achieve something similar with my Statement
> package:
>
> package Statements is
>
>     type Statement is abstract tagged
>        record
>           tokens : Vector;
>           executedtokens : Vector;
>        end record;
>
>     type Statement_Access is access all Statement'Class;

Do you need this pointer type right here or in any child packages
of Statements, and in such a way that it is globally visible,
and in scope everywhere Statement is? If so, do the pointers need
to be pointing to non-constant Statement objects on the stack
as well? If not, you could start by omitting the "all", or replace
"all" by "constant".

Insofar as tagged objects are by-reference types already,
explicit pointers are rarely needed for "O-O effects". This is somewhat
like Java, which, for O-O objects, passes references. (But needs
"new" allocators when creating O-O objects, unlike Ada.)
Pointers can become necessary in case one record type needs
to have a component of any type from a hierarchy like Animal'Class.
That's because the specific type isn't known yet: could be Dog, Pig,
Hound_Dog, Spider, ..., but the compiler needs to establish the
'Size of the record type, hence indirection because a pointer
has a known size. It's like declaring a field of type Animal
in a Java class and assigning it a Dog object reference,
or Pig object reference, etc.


> So when I create a child of Statement, how to I set up the .ads file?

As said, you do not even need to put a child type in its own package.
If you choose to pick from the setups Simon has shown,
and if such a package should be translated with GCC, the default
method requires file names to be "expressions.ads" and
"statements-expressions.ads", respectively.