class ZQueen: public ZNameMap, public An_ID_Demangler, public MIR_Priest

 Initializes a new queen and creates mandatory lists.
 Called from ZKing.
 Not applicable for activation or instantiation of not Ruling Queens.

 Initializes *this* queen with unstreamed queen.
 Copies Links and List contents, no ref-counting is performed.

 Assigns an ID to lens.

 Releases ID-space occupied by recently dead lenses.
 Also performs deletion of lenses that were still referenced
 by viewers at their death-time.

 Mirrors purgatory release at moons.
 Also performs deletion of lenses that were still referenced
 by viewers at their death-time.

 This should serve to properly demangle external references for comets.
 And check that the id is within the queen's dependencies.

 Allow beta/gamma from queens that *this* depends on + queen
 arguments if alpha is *this*.

 should check that the mir is valid and within deps.
 If whorequeen should accept new ones and append them.
 If light-queen with FollowDeps should append with broadcast
 PRIOR to returning from this method.
 Called from Saturn::Unfold() prior to locking and execution.
 Errors/non-conformance should be reported by throwing an exception.

 Oh yess ... btw ... queens can as well block all execs to their
 subjects. Eg, when bMIRActive of alpha is false.
 Per queen access control can be implemented here.

 Returns true if *this* depends on some_queen, i.e. if my lenses
 can reference lenses ruled by some_queen.

 PostMIR version.
 Instantiates a glass of FID(lid, cid) and attaches it to attach_to
 by using last part of the message, which should be a properly
 formulated Ctx call.
 Ctx for this call is:
 alpha ~ attach_to, beta ~ new glass, gamma ~ attach_gamma
 Returns ID to the caller (also via MirResult if set in MIR).

 Incarnates a new glass from the buffer and then attaches it in the
 same manner as the above method.
 Links and list contents are rebuilt in accordance with queen's dependency
 state.

 First step in the process of a lens removal.
 Stops all detached threads via Saturn::Freeze().
 Removes all references to a lens and sends Rays with RQN_death.
 Then emits MIR to PutLensToVoid(lens).

 Puts all elements of list having mQueen==this to purgatory.
 Copies list contents, clears the list and then purges
 individual elements. This optimizes removal procedure for
 large lists.

 Final step in lens removal.
 Endarks the lens.
 Clears up internal structures.
 Deletes the lens (or makes it a zombie).

 Initiates removal of lens. This is the method that should be called
 by user.
 If called as Flare broadcasting is suppressed.
 Does not have to be called under any lock as it shoots a MIR to
 itself to initiate the lens destruction.

 Remove elements of list. Does NOT cross queen boundaries.
 Spawned in a dedicated thread.

 Low-level lens remove initiator. Called on queen's Sun.
 Only checks if lens is already dying.

 Low-level massive lens remove initiator. Called on queen's Sun.

 Called by ZGlass upon hitting refcount of 0.
 mSubjectRefCntMutex is (and should be) locked prior to call.

 Virtual. Creates reflection that can be invoked to produce a copy
 of queen-space on other Saturn.
 ZQueen itself just creates and streams a ZComet.

 Virtual. Invokes reflection created by a higher Saturn and thus
 begins mirroring the object-space.
 For ZQueen this involves unstreaming of ZComet and calling UnfoldFrom().

 Virtual. Cleans up queen-space, putting it back into non-ruling state.

 Produces Comet of type ST_Queen.
 Contains all glasses ruled by the queen.
 External references are streamed as IDs and can be reconstructed
 at lower Moons.
 Used for producing a snapshot of Queen-space to be sent to a Moon.

 Adopts a Comet of type ST_CometBag.
 External references of a Comet are ignored.

 Unfolds a dormant (not bRuling) queen from a comet of type ST_Queen
 and makes it a ruling queen.
 The incoming queen and its Deps are replaced with already present ones.
 Does NOT call CheckIn ... does it directly with simultaneous building of
 free block list.
 At the end calls AdUnfoldment on all lenses.

 eventually lock mRayMutex and do direct ray delivery

 attempt at looking at all subjects based on ids
 else might be forced into having local hash.

 Subject Write/RefCnt locks.