I act as an indirect reference to an object accessed through a
pb.Perspective.

Simply put, I combine an object with a perspective so that when a peer
calls methods on the object I refer to, the method will be invoked with
that perspective as a first argument, so that it can know who is calling
it.

While Viewable objects
will be converted to ViewPoints by default when they are returned from or
sent as arguments to a remote method, any object may be manually proxied as
well. (XXX: Now that this class is no longer named Proxy, this
is the only occourance of the term 'proxied' in this docstring, and may be
unclear.)

This can be useful when dealing with pb.Perspectives, Copyables, and Cacheables. It is
legal to implement a method as such on a perspective:

This will allow you to have references to Perspective objects in two
different ways. One is through the initial 'attach' call -- each peer will
have a pb.RemoteReference
to their perspective directly. The other is through this method; each peer
can get a pb.RemoteReference
to all other perspectives in the service; but that pb.RemoteReference
will be to a ViewPoint, not
directly to the object.

The practical offshoot of this is that you can implement 2 varieties of
remotely callable methods on this Perspective; view_xxx and
perspective_xxx. view_xxx methods will follow the
rules for ViewPoint methods (see ViewPoint.remoteMessageReceived),
and perspective_xxx methods will follow the rules for
Perspective methods.

The default implementation is to dispatch to a method called
'view_messagename' to my Object and call it on my object with
the same arguments, modified by inserting my Perspective as the first
argument.