Re: I'm facing an issue with: call to abstract procedure must be dispatching

[Jere <jere.groups@gmail.com>]

On Tuesday, December 8, 2015 at 6:04:08 PM UTC-5, Serge Robyns wrote:
> On Tuesday, 8 December 2015 23:55:52 UTC+1, Jeffrey R. Carter  wrote:
> > If you don't need assignment because there will never be more than one of them,
> > that's an indication that you don't need a type and a variable; you need a
> > module. I suspect you think in terms of types because C++ only provides
> > encapsulation and information hiding through its class construct. In Ada, your
> > 1st thought when you want encapsulation or information hiding should be a pkg.
> > 
> 
> How do I then pass the context?  I mean, now I pass the parameter around.  through global variables?  Also in the future I would like to have multiple "tasks" running, each with their "context", especially the db session.  I do believe these are good reasons for having a variable.

If will be having multiple ones with their own contexts then you will have to use objects from types to do that.  However, if you are only going to have one, then as Jeffrey Carter suggested, just use a package.  A useless uncompiled example (I don't have GNAT in front of me here):

package My_Package is

   type Data_Type is record
      Value1 : Integer := Integer'First;
      Value2 : Positive := Positive'First;
   end record;

   procedure Update_My_Data(Data : in Data_Type);
   function  View_My_Data return Data_Type;

end My_Package;

   
package body My_Package is

   My_Data : Data_Type;

   procedure Update_My_Data(Data : in Data_Type) is
   begin
      My_Data := Data;
   end Update_My_Data;

   function  View_My_Data return Data_Type is
   begin
      return My_Data;
   end View_My_Data;

end My_Package;

My_Data is only accessible via the package body, so any clients have to use the provided functions of the package to manipulate or look at the data.  This example is over-simplistic, but I just wanted to show you the layout.  It's not the same as using a global since the clients can't access the variable directly and you have the freedom to have the public interface hide some implementation details on how the data is actually handled.

Since you are familiar with C++, it has a similar construct (I use it for peripherals in small embedded systems):  A class with only static members and static methods.  In this case, you are not using the class to generate objects but to organize methods and data with the ability to make some of them private (which you cannot do in a namespace) while also being able to retain a private non-global static state for one thing.  It is not as elegant as an Ada package and there are still some differences, but it is the closest analog to this that C++ has.