This method creates methods on the prototype of a class that delegate to an object that the class contains. It is useful when creating wrappers for classes.

Because this function adds methods to the prototype, if you replace the prototype after calling this method, you will lose all the delegated functions. For this reason, if you intend to call caplin.extends or caplin.implements, you should do so before calling this method.

After you have called this function, all methods from the interface will have been added to your class, but you can then modify any that you wish to have different behaviour.

Example:

// An interface I'm using for this example
class AnInterface {
 sayHello() {}
 sayGoodbye() {}
}
// The wrapper that uses delegate
class MyWrapper extends AnInterface {
constructor(wrappee) {
if ( ! isImplementorOf(wrappee, AnInterface) ) {
throw new Error(Error.INVALID_PARAMETERS, 'MyWrapper: wrappee must implement AnInterface.');
}
this.aWrappedClass = wrappee;
}
}
ClassUtility.delegate(MyWrapper, AnInterface, 'aWrappedClass');
// Now all calls to sayHello or sayGoodbye on instances of MyWrapper are proxied on to this.aWrappedClass.
// If I wish to modify behaviour I can do it now:
MyWrapper.prototype.sayGoodbye = function() {
this.aWrappedClass.sayGoodbye();
console.log('or is it.....')
};

Obviously this example uses a simple interface, this method is more useful if there are many methods on the interface that you will wish to pass through to a wrapped object.

Since it's not possible for this function to do it for you, in the interests of failing fast, you may wish to check that the object you are wrapping is an instance of the intended interface before you assign it to the named field. Also, bear in mind that trying to call methods before it is assigned will cause errors. It's usually best practice to ensure that the wrapped object is passed into the constructor and this field is assigned to early.

This method should make it less painful to 'prefer composition over inheritance'.

Augments a classDefinition to implement a given Interface.

Any method implementations provided in the methods map are override those defined on the interface.