Breaking a circularity

[Gene <gene.ressler@gmail.com>]

Need some expert help here with a circularity in the data structures
for a discrete event simulation.

We need event queues and an arbitrary number of event types.  The
handlers for events must have access to a simulation state record, so
used a generic thus:

generic
   type State_Type is private;
package Event_Queues is

   type Event_Type is abstract tagged limited private;

   procedure Handle(State : in out State_Type;
                    Event : access Event_Type) is abstract;

   type Event_Ptr_Type is access all Event_Type'Class;

   procedure Add(Event_Queue : in out Event_Queue_Type;
                 Time : in Time_Type;
                 Event : access Event_Type'Class);

   -- other methods not shown.
private

   type Event_Type is abstract record
      Id : Positive;
      Time : Time_Type;
   end record;

   function Sooner_Than(A, B : in Event_Ptr_Type) return Boolean;

   -- We are just going to put a thin wrapper around Ada ordered sets
to
   -- implement our event queue.
   package Event_Queues is
     new Ada.Containers.Ordered_Sets(Event_Ptr_Type, Sooner_Than,
"=");
   type Event_Queue_Type is new Event_Queues.Set with null record;

end Event_Queues;

Here's the circularity:  Instantiating an event queue requires the
simulation state type, but the simulation state must contain an event
queue (of the instantiated type).

This is the best I've come up with so far:

private
   type Event_Queue_Wrapper_Type;

   type State_Type is
      record
         Future_Events : access Event_Queue_Wrapper_Type;
         -- other stuff not shown
      end record;

   package Simulation_Events is
     new Event_Queues(State_Type);

   -- Now we can define the wrapper to contain the event queue.
   type Event_Queue_Wrapper_Type is
      record
         Queue : Simulation_Events.Event_Queue_Type;
      end record;

Is there a cleaner way to do this?  The painful part is introducing a
pointer to the event queue in State_Type just to break the
circularity, when this seems superfluous and means I should make
State_Type controlled to release the queue.