The parent method implementation calls proxyFunc.apply and passes as parameters this and the modified arguments array args. Then when the function associated with the proxyFunc variable is executed, whenever this is referenced, the correct object instance is referenced. Using apply is extremely useful and simplifies the proxy method implementation. The downside is that the original method passed to the proxy method must also use apply. If when calling the original method the proxy function does not use apply, then errors might be generated.

When executed, the generated code will work properly. The challenge lies in the generation of the code. One approach is to generate a text buffer that represents the complete implementation of the proxy method. Another approach is to dynamically generate and evaluate some parts of the generated code, and use a dynamic function for the other parts. Each of these solutions is problematic, and the best solution is to use JavaScript generics. Using JavaScript generics, you can define the desired code, and at runtime the behavioral aspects can be expanded. The following code is the complete proxy generation solution.

   Source: /website/ROOT/scripts/jaxson/common.js
   proxy : function(instance, funcIdentifier,  newFunc) {
   if (!instance[funcIdentifier]) {
   throw new Error("Method does not exist on  this
   object (" + funcIdentifier +  ")");
   }
   var proxyPrototype = function() {
   var origFunc = __orig;
   var proxyFunc = __proxy;
   var args = new Array();
   for (var c1 = 0; c1 < arguments.length; c1  ++) {
   args.push(arguments[0]);
   }
   args.push(origFunc);
   args.push(arguments);
   return proxyFunc.apply(this, args);
   }
   instance[funcIdentifier] = Generics.expand(proxyPrototype,
   {
   __orig: instance[funcIdentifier],
   __proxy: newFunc
   });
 },

The proxy implementation does not need much explanation, because the code has already been largely explained. Look at the definition of the proxyPrototype variable, and you should notice a similarity to the ideal generated code that was explained throughout the article. The only difference with proxyPrototype and the ideal code is that the values for origFunc and proxyFunc have not been defined.

The origFunc and proxyFunc variables have been assigned the __orig and __proxy variable values, which are identifiers used in the JavaScript generics expansion. The call to Generics.expand will expand the buffer to resemble the ideal buffer. The parameters to the proxy method are instance, which represents the object instance to generate a proxy method implementation; funcIdentifier, which represents a string buffer of the method to proxy; and newFunc, which represents the proxy function that is called before the original.

   The proxy method can be used as shown in the  following example.
   Source: /website/ROOT/ajax articles/javascript/proxy.html
   automated_proxy : function() {
   var cls = new DefinedClass();
   info("automated_proxy{cls.defined|before}",  cls.defined.toString());
   ops.proxy(cls, "defined",  function(tstValue, toCall, args) {
   info("proxyfunction", "parameter  (" + tstValue + ") received arg count (" +
   arguments.length + ") original arg count  (" + args.length + ")");
   toCall.apply(this, args);
   });
   info("automated_proxy{cls.defined|after}",  cls.defined.toString());
   cls.value = 10;
   cls.defined(10);
 }

In the implementation, the DefinedClass type is instantiated and assigned to the cls variable. For purposes of illustration, the implementation of cls.defined is generated (info(..., cls.defined.toString)) to show what the original method implementation is. The call to ops.proxy has three parameters, and the first two parameters (cls and "defined") are obvious. The third parameter is the proxy method, and in the case of the example, it is an inline-defined function. The third parameter does not have to be an inline method; it can be a function reference or another class instance. After the call to ops.proxy is another call to the info function to illustrate the modified version of the cls.defined method.

Tip To test your own understanding, run the test code from the samples to see how the code works. The last line of code that calls the defined method illustrates that the proxy method is called before the original method. When implementing the Proxy pattern for a method, keep the following points in mind:

• The Proxy pattern for a method is applied when you want to filter, preprocess, and postprocess parameters before (if) they are passed to the method.

• The implementation of the proxy method is responsible for calling the original method.

• The Proxy pattern for a method is best implemented by embedding functions within functions. The advantage of using an embedded approach is that the function can be referenced by other object instances without corrupting the method implementation.

• The Proxy pattern for a method can be embedded multiple times.