Script nachladen falls benötgt

[molily]

function publicInterface (implementation) {
      this.implementation = implementation;
  }
  publicInterface.prototype = {
      get : function () {
          return unserialized(this.implementation.get());
      },
      set : function (value) {
          return this.implementation.set(serialized(value));
      },
      /* ... */
  };

Das ähnelt im Grunde dem Public-Teil des »Implementation Template« mixins.serialized, von dem derzeit alle Implementerungen Gebrauch machen. Nur dass ich die Funktionsweise der Implementierungen an der Stelle festschreiben würde.

Bisher gibt es Implementations, die mixen Implementation Templates und darüber Serializer ein. Ich sammle also alle nötige Logik in einem Objekt und letztlich werden einige Methoden dieses über Referenzen zusammengeklaubten Objektes an das Public Interface kopiert (»veröffentlicht«), das ganze Objekt in der Eigenschaft implementation sowie die Methode forceImplementation verfügbar gemacht:

/* Set up the public interface object */  
var publicInterface = {  
	/* Provide active (auto-detected) implementation */  
	implementation : imp,  
	/* Provide method to force another implementation */  
	forceImplementation : helper.bind(this.force, this)  
};  
  
/* Provide core methods from the implementation */  
helper.forEach(["get", "add", "remove", "clear"], function (methodName) {  
	/* Copy the bound function to the public interface */  
	publicInterface[methodName] = helper.bind(imp[methodName], imp);  
});

Dort in implementation.setup() könnte ich natürlich noch eine Abstraktionsebene einführen, indem ich das publicInterface von einem Konstruktor bauen lasse, der Wrappermethoden für get, add, remove und clear bietet und die intern auf this.implementation umleitet.

Das erscheint mir aber keine Vereinfachung zu sein, stattdessen bleibe ich dort beim Herumreferenzieren) von Methoden sowie deren Binding, wie ich es auch im Rest des Scripts anstelle von Klassenhierarchien tue.

Beim gegenwärtigen Aufbau müsste es z.B. recht einfach möglich sein, die vorhandene DOM-Storage-Implementierung zu verwenden, aber einfach einen anderen Serializer hineinzumixen.

implementation.add(implementation.get("domstorage), {
   name : "domstorage with my own serializer",
   serializer : {
      init : ...,
      serialize : ...,
      unserializer : ...
   }
});
)

... einfach weil der Ablauf (Definieren -> Entscheiden -> Verknüpfen, -> Installieren) sehr viel linearer ist und der Unterschied zwischen öffentlichem Objekt und Backend genauer rauskommt.

Ja, das stimmt schon.

Mathias