What is the best method for transmitting objects/tagged records?

[Shark8 <onewingedshark@gmail.com>]

I've been stumped for a while trying to consider how to use Streams
and the Distributed Systems Annex (Annex E) together for a parser;
such that a [possibly] remote task can take a stream (parsing text to
tokens could be done on either the client or host-systems and that
division still suffers from this problem) and generate an object from
it.

I'd originally had something like this:
- Entry: Read String
- Entry: Write Object

But this doesn't work for a class-wide object. As the only way to get
an object from a task is via an out parameter (meaning we cannot use
it as an initialization to some class-wide variable); we cannot safely
over-write an existing object of some similar class because we may be
passing out an extended object (which can only be bigger) which would
stamp on the adjacent memory.

So, Dimitry kindly pointed me to the correct way of doing so:
- Entry: Read String
- Entry: Write Tag
- Entry: Write Object over a class-wide variable which had been
initialized to the correct type via the dispatching constructor.

But the package Ada.Tags is of the wrong type/level to be included in
a remote_types or remote_interface package, so I cannot use that
method.

How would you go about transmitting tagged records across partitions
(with the intent that these partitions should be easily separable for
distribution at a later date)?

OR Should I just rewrite my package-hierarchy keeping in mind the
Remote_interface/Remote_Types/etc pragma restrictions?

Further, I concede that perhaps this is the wrong area to try to self-
teach (distributed computing) so any pointers to tutorials for using
the DSA would be welcome.