SuperCollider : protoType

SuperCollider :: Categories :: PageIndex :: RecentChanges :: RecentlyCommented :: Login/Register

rappel sur les Classes


utilité


* stockage pour réutilisation de processus, de fonctionalités ->
* abstraction de processus ->
* extention, personification des fonctionalités du langage ->
* redéfinition de règles d'utilisation du langage

définition


* un objet représente un agent auquel on peut adresser des messages
* ces messages
* changent l'état interne de l'objet (variables d'instances)
* ou opèrent et retourne une valeur
* en bref, un objet est fait de fonctions (méthodes) et de variables (méhtodes+ données)
* dans ce contexte, peu importe la constitution de l'objet, puisque tout changement, tout accès se fait par passage de message (encapsulation)

fonctionnement


* les fonctions constituant les méthodes sont compilées dans une table de méthode, pour un accès plus efficace et rapide dans l'utilisation du langage
* les changements dans les méthodes existantes et la structure des classes ne sont pris en compte qu'après re-compilation (cmd-k, ou ctrl-c l dans emacs) -une exeption: on peut ajouter une méthode dans un objet sans recompilation avec le message .addUniqueMethod

prototypage de classes

utilisation de dictionnaires (IdentityDictionary)

* permet une conception rapide et souple d'une structure en vue de la création d'une classe
* un IdentityDictionary peut "émuler" le fonctionnement des variables d'instances et des méthodes:
( a = ( x:4, //variable avec valeur y: { 1.0.rand } //fonction -> méthode ); a[\x] + a[\y].value; )

les IdentityDictionary peuvent retourner la valeur correspondant à une clef en recevant cette clef sous forme d'appel de méthode :

a.x; a.y;

à condition cependant que la variable d'instance .know du dictionnaire prennent comme valeur true (ce qui est sa valeur par défaut)
a.know_(true)

On peut ainsi imiter le fonctionnement d'un Objet, pouvant être changé dans sa structure sans recompilation:
setter
a[\y] = {Array.rand(8, 0, 1)}; ou mieux encore: a.y = {Array.rand(8, 0, 1)};
getter
a.y;


argument des pseudo-méthodes
attention, en cas d'appel d'une fonction définie à l'intérieur d'un dictionnaire, le premier argument est le dictionnaire lui-même:
isit = (\vfunc: {"vfunc"} );
~thing=(\tfunc: { |self, visiteur|
Post << " contenant: " << self << " - visiteur: " << visiteur.vfunc << "\n" });
~thing.tfunc( ~visit );

héritage

* on peut même émuler l'héritage grâce aux méthodes parent et proto définies sur IdentityDictionary : b = (z: pi); a.parent = b;

a.y + a.z
ici, a recoit en héritage une clef définie sur son parent b

héritage multiple

* avant de chercher une clef dans le parent, le dictionnaire la cherche dans un dictionnaire défini comme proto il est possible ainsi de créer une structure avec héritage multiple:
r = (goug: 1987);
r.know = true;
a.proto = r;
a.fox; a.goug; //hérité de r
a.goug = 2000; //getter
a.trup = 456; //setter
a.z; //hérité de b (plus haut)


ici, a hérite à la fois de r en tant que proto et de b en temps que parent .
autres exemples
o = ( a:2, times2: { |self, b| b.isNil.if({ self[\a] * 2 // retourne la "variable d'instance" a }, { b * 2 // utilise l'argument b }) });
o.times2(5) //10
o.times2 //4

Autre exemple

There are no comments on this page. [Add comment]

Valid XHTML 1.0 Transitional :: Valid CSS :: Powered by Wikka Wakka Wiki 1.1.6.3
Page was generated in 0.1290 seconds