Re: how to import a package

["markww" <markww@gmail.com>]

Thanks all I think I got it now. Dmitry A. Kazakov, Adam Beneschan,
your posts really showed me how to set it up. Now I have all the list
functions as part of that package and it's working as expected for a
generic list.

I'm wondering still if it's possible to have a data member in the
package definition that serve as my start and end nodes. In C++ I'd do
something like:

    struct List {

        AddNode(...);
        DeleteNode(...);
        ...

        Node *pStart, *pEnd; // keeps track of start and end nodes for
a single list instance.
    }

am I allowed to do the same in my package definition? Then things would
be a lot neater. Right now I have the start and end pointers as
variables external to the package, so everytime I call AddNode() etc I
have to pass them through which is pretty sloppy. It looks like:

    generic
        type T is private;
    package Generic_List is
        type Node;
        type Node_Ptr is access Node;
        type Node is limited record -- We don't copy nodes
            Data : T;                -- The data in the node
            Prev : Node_Ptr;         -- Previous node, else null
            Next : Node_Ptr;         -- Next node, else null
         end record;

       procedure Add(Start : in out Node_Ptr; Last : in out Node_Ptr;
Data : T);
       procedure Delete(Start : in out Node_Ptr; Last : in out
Node_Ptr; nIndex : INTEGER);
       function GetNodeCount (Start : Node_Ptr) return INTEGER;
       function GetNode(Start : Node_Ptr; nIndex : INTEGER) return
Node_Ptr;
       function GetNodePosition(Start : Node_Ptr; MatchData : T) return
INTEGER;

      -- Something like:
      m_Start : Node_Ptr;
      m_Last : Node_Ptr;

   end Generic_List;

then externally I'd hope to use it like:

    GenericList.Add(T);

instead of what I'm doing now:

    GenericList.Add(Start, Last, T);

Thanks,
Mark

Jeffrey R. Carter wrote:
> markww wrote:
> >
> >     procedure Add_Record(GenericData : PERSON_REC) is
> >     Temp : gNode.Node_Ptr;
> >     begin
> >
> >         Temp := new gNode.Node;
> >         Temp.Data := GenericData;
> >     end Add_Record;
>
> This leaks memory.
>
> Others have discussed the solution to your specific problem, but I think
> what you're missing is the general mind-set that a type definition and
> the operations on that type should be encapsulated in a package. So far,
> you only have 1 operation (Add_Record), but in a generally useful
> linked-list package you'd probably have a lot more. Those operations
> should be in the package; then, whenever you instantiate the package,
> you get the operations.
>
> This concept, encapsulation of data and their operations (usually with
> hiding of the data's structure), is called "object orientedness". In
> many languages, this design concept is mixed up with the implementation
> concept of programming by extension (incorrectly called OOP); for
> example, in C++, you get both from the "class" construct. In Ada, the 2
> are separate.
>
> At this point, you might find it instructive to look at some existing
> linked-list packages, such as the one in the Ada-0X container library,
> or the ones in the PragmAda Reusable Components
>
> http://pragmada.home.mchsi.com/
>
> or many of the component libraries you can find at adapower.com or
> adaworld.com.
>
> --
> Jeff Carter
> "Blessed is just about anyone with a vested interest in the status quo."
> Monty Python's Life of Brian
> 73