Re: A clarification on Capabilities, Parameters, createParameters, and filterParameters.

I missed that when I originally looked at Principle #4:
filterParameters(createParameters(), C) == createParameters(C)

I'm not sure this fully defines what this this means for all scenarios. 
Plus given a local systems understanding of "C" might be greater or less 
than a remote systems understanding of "C", I'm not sure that statement 
is actually true. Also a createParams on a receiver may differ in its 
return results than a createParams would on a sender, even given the 
same caps (senders and receivers don't always require the sam level of 
detail).

There are 8 (or more) usage scenarios. Not sure which is legal, 
duplicate, possible, useable, and what they all mean and what to do in 
all scenarios.

sender.filterParams(senderParams, senderCaps);
sender.filterParams(receiverParams, senderCaps);
sender.filterParams(senderParams, receiverCaps);
sender.filterParams(receiverParams, receiverCaps);

receiver.filterParams(senderParams, senderCaps);
receiver.filterParams(receiverParams, senderCaps);
receiver.filterParams(senderParams, receiverCaps);
receiver.filterParams(receiverParams, receiverCaps);

Where senderParams was created using sender.createParams();
Where receiverParams was created using receiver.createParams();

And that's not even considering this:
altSenderParams = sender.createParams(receiverCaps);
altReceiverParams = receiver.createParams(senderCaps);

Examples 8 and 9 use remote caps but the API doesn't say what is 
expected. Even if I understand the vague principle of what it might do, 
I'm still not clear on what it actually does in detail... I can't just 
see it as a remote version of the createParams algorithm as it 
manipulates an existing param set based on capabilities instead of 
constructing new ones. I am not exactly sure I can explain what it 
really does to the level someone could go ahead and implement it...

-Robin


> Bernard Aboba <mailto:Bernard.Aboba@microsoft.com>
> May 10, 2014 at 4:26 PM
> Peter Thatcher said:
>
> This could be done entirely in JS, but for simple use cases, that's 
> kind of a pain, so we introduce a second convenience function: 
> filterParameters.
> It has a simple meaning:
>
> (1) filterParameters(createParameters(), C) == createParameters(C)
>
> [BA] It makes sense to me that calling a local filterParameters 
> function on locally created parameters along with remote capabilities 
> would produce the same result as calling the local createParameters 
> function on those same remote capabilities.
>
> However, there is another use of filterParameters in Example 8 of the 
> Editor's draft, which is calling the local filterParameters function 
> on parameters created on a remote system and (implicitly) filtering 
> them through the local capabilities.
>
> For this case, I am wondering if there is an equivalent relationship 
> to equation (1) above. For example, do we believe that the following 
> relationship holds?
>
> (2) filterParameters(remoteCreateParameters()) == 
> remoteCreateParameters(localCapabilities)
>
> The above relationship seems to require some additional assumptions 
> beyond the first one, which is that the local filterParameters 
> function is compatible with the remote createParameters function.
>
> [Peter] 1. Exchange capabilities, and then parameters use 
> createParameters (2 round trips, but extremely easy).
>
> [BA] If relationship (2) holds, it would seem that exchanging 
> capabilities would be sufficient without having to exchange parameters 
> over the wire, because those parameters are derivable on the remote 
> system without having to send them.
>
>
>
>
>