On Nov 25, 2007 3:11 PM, Mr. SpOOn <[EMAIL PROTECTED]> wrote:
> Quando dici due oggetti intendi due classi, no?
No. Nella fattispecie intendo due oggetti. Questi saranno istanze di
due classi. Il punto è che al limite l'encoder e il decoder potrebbero
anche essere funzioni. Sono rispettivamente aggeggi cui passi il
messaggio iniziale e lui te lo encoda e l'altro è quello che prende il
messaggio trasmesso e lo decodifica
Come ti ho mostrato questi oggetti possono essere 'composti' dentro la
classe Channel (nel qual caso intendi un canale con già capacità
'estese' di codifica e decodifica) oppure un canale 'ridotto' (cui
passi i messaggi già encodati e il cui risultato viene lavorato poi
dal decoder.
Io sono un matematico e non un ingegnere telecom, ma generalmente il
'canale' non ha proprietà di codifica e decodifica (visibili
dall'esterno, se è roba sua, fatti suoi). Per cui il design più pulito
che vedo è quello che non 'setta' encoder e decoder. Questo sulla base
di una mia comprensione limitata e teorica della materia (teoria
dell'informazione ne ho fatta, ma più da un punto di vista matematico,
appunto, che ingegneristico).
Tuttavia l'ingegnere del software che è in me vede la soluzione in cui
usi i setEncoder e compagnia come più pragmatica e comoda da
programmare. Questo ammesso (e non concesso) che tu voglia avere
encoder e decoder 'pluggabili'. Per esempio per fare vedere che se
spari dentro il canale rumoroso una cosa compressa con huffman puro
(per dire) quello che esce è spazzatura (mi aspetto), se invece
reintroduci della ridondanza, ricostruisci il messaggio.
Direi che è un design ragionevole per giochinare con i codec. E'
quindi un design in qualche modo conscio dell'implementazione
ragionevole delle cose.
Nulla ti vieta di avere un NoiseChannel che mette solo il rumore e un
più generico Channel che contiene il NoiseChannel e ha i famosi
setEncoder e compagnia.
> In effetti adesso con una classe Channel mi si risolvono un po' di
> problemi, credo.
I think so. :)
> Posso usarla per gestire degli oggetti che servono durante tutto il
> processo, come ad esempio il messaggio codificato e il tipo di
> codifica scelto.
Ah, io direi no. Il canale fa *una* cosa. Simulare il rumore e basta.
Il tipo di codifica la sanno la coppia encoder-decoder. Che in uno dei
due design sono messi pure dentro il canale, quindi in questo senso
si, vediamo il canale in modo esteso e amen.
> Quindi penso di definire il metodo che codifichi il messaggio
> all'interno della classe Encoder.
Attenzione, l'encoder potrebbe anche essere una funzione. Molto più pratico.
A questo punto se è un'istanza di una classe custom usi __call__ e hai
un oggetto function-like.
> Questo metodo lo chiamo dalla classe
> principale Channel (in un altro metodo tipo setEncodedMessage) che
> andrà a modificare il valore di encodedMessage presente in Channel.
Non mi piace vederla così. Per me un canale è un oggetto dove la roba
*passa*. Usare un concetto di 'setMessage' mi piace davvero poco. Un
canale non è una scatola: è un tubo. Io userei proprio read e write.
In primo luogo lo rendono un oggetto file like (il che non guasta), in
secondo luogo rendono bene l'idea.
Dentro il NoiseChannel avrai una lista che tiene i messaggi (gestita
come una coda). E poi resta da decidere se prendi il messaggio pulito
e lo sporchi quando lo tiri fuori dalla coda perchè te lo hanno
chiesto oppure se sporchi appena ti entra un messaggio, lo salvi in
coda sporco e lo tiri fuori (ovviamente così come è).
Io farei qualcosa di simile a questo (con i due noise channel che
mostrano due diverse implementazioni incomplete):
class NoiseChannel_1(object):
def write(self, message):
fuzzed_message = self.fuzz(message)
APPEND(fuzzed_message)
def read(self):
return POP_FRONT()
class NoiseChannel_2(object):
def write(self, message):
APPEND(message)
def read(self):
return self.fuzz(POP_FRONT())
class Channel(object):
encoder = property(...)
decoder = property(...)
noise_channel = property(...)
def __init__(self, noise_channel, encoder, decoder):
self.encoder = encoder
self.decoder = decoder
self.noise_channel = noise_channel
def write(self, message):
self.noise_channel.write(self.encoder(message))
def read(self):
return self.decoder(self.noise_channel.read())
Nota che il codice sopra non è testato, non è manco valido
sintatticamente forse (e certamente non semanticamente). E' una
traccia che ho scritto in pseudo-Python per motivi di rapidità.
--
-enrico
_______________________________________________
Python mailing list
Python@lists.python.it
http://lists.python.it/mailman/listinfo/python
