Mi sembra funzioni correttamente!

Dopo il

Codice: [Seleziona]

settings["test"] = casuale

io metto normalmente

Codice: [Seleziona]

Settings.save

ma comunque funziona.

appunto...
settings.save non serve poichè la routine _free() della classe settings ci pensa da sola a salvare la configurazione senza bisogno di salvarla manualmente quando l'applicazione si chiude
e nella mia settings modificata blocco l'esecuzione con una if condizionata dalla proprietà abilita

Questa discussione mi sembra la maratona di telethon....
Grazie per la pazienza....

EDIT:
Settings.save serve perchè salva immediatamente la configurazione ( e quindi all'uscita non viene di nuovo eseguito)
se all'uscita viene rilevato che qualche cosa è cambiato e non è stato ancora salvato allora viene chiamato lo stesso il metodo .save dalla routine _free()
Quindi se non salviamo noi manualmente i cambiamenti verranno comunque salvati in automatico all'uscita
 

Ragazzi non so cosa dirvi
Gambas installato da ppa e provato su 6 pc diversi  ( linux mint, ubuntu xfce, ubuntu kde) piu installazione su raspberry compilato da sorgenti
in ogni caso allego il programma così come lo pensavo con la modifica alla classe settings

Prova a togliere l'ultima istruzione
settings.wriite(me)
nel tuo codice

La mia applicazione è molto specifica e il problema fondamentale è che le impostazioni le devo salvare subito poichè potrebbe succede che venga  a mancare la tensione  ciò che ho modificato andrebbe perso, quindi ogni volta che modifico un parametro faccio subito settings.save
Il problema è che se lo fa comunque alla fine ci sono probabilità di corruzione del file .conf poichè potrebbe accadere che venga tolta immediatamente ( ma è un problema della mia configurazione e non comune a tutti, lo definirei un problema di nicchia...)

quello che non riuscivo a capire e cio che ha generato l'esigenza di chiedere informazioni con un post era la questione riguardante inherits

dalla wiki avevo inteso che ogni volta che si deriva una classe da un altra se scrivo una funzione con lo stesso nome di una presente nella classe geniitrice  essa si sostituisce a quest'ultima
se però voglio richiamare la funzione originale posso farlo usando SUPER
evidentemente questo meccanismo non funziona, o funziona in maniera differente con i metodi nascosti nella classe settings
perlomenno questo credo di aver capito

Credo che il fatto di aver messo troppa carne al fuoco abbia solo portato confusione

La questione principale è
derivando la classe settings con inherits mi aspetto che anche il metodo ( o evento )  _free() venga sovrascritto dal nuovo codice che metto nella classe derivata cosi come accade per altri metodi
sembra che così non funziona e il metodo (o evento) _free continua a funzionare così come scritto nella classe genitrice.

Il motivo per cui ho deciso di derivare la classe Settings è che voglio evitare che alla sua distruzione ( e conseguente chiamata della funzione _free() avvenga il salvataggio del file di configurazione generato da Settings, ma che tale salvataggio possa o meno avvenire abilitato da una nuova proprietà che definisco nella classe derivata da Settings

Tutto questo nasce dal fatto che Ext4 con journaling ritarda a volte la scrittura su disco delle modifiche e che un file cancellato dal sistema operativo ( e che non risulta piu presente ad esso) torni poi miracolosamente in vita se nell'istante che viene cancellato il sistema si blocca per una mancanza di tensione
Ciò è particolarmente piu evidente in raspberry poichè usa una sd e al ritardo di ext4 si aggiunge la lentezza di scrittura su disco
Ciò può compromettere anche il file .conf se immediatamente dopo la chiusura dell'applicazione (e conseguente salvataggio) si toglie immediatamente l'alimentazione ( e questo non posso evitarlo)

Aggiungo che i file cancellati non risultano piu presenti al sistema operativo e che quindi non è possibile scoprire se ci sono ancora fisicamente su disco
Questo ritardo di scrittura determinato dal journaling può essere molto breve, puo capitare a volte che invece sia un po piu lungo, magari perchè il sistema è impegnato
Naturalmente un effetto del genere si evidenzia solo in caso di mancanza di alimentazione o crash del sistema che in genere sono eventi rari; nel mio caso invece può accadere con piu facilità dato l'utilizzo che faccio con raspberry ( e non posso usare un ups...)

Quindi la domanda a cui non riesco a dare risposta è semplicemente e solo:
perchè derivando la classe settings la funzione _free non viene sostituita da quella che scrivo io ma rimane attiva quella originale?
Presumo che avere a che fare con i metodi nascosti possa generare comportamenti diversi da quelli che ci si aspetta e qualche mal di testa in piu

Tutto il resto l'ho aggiunto per condividere una esperienza, ma mi rendo conto che ha generato solo confusione e non era il contesto giusto

Ribadisco che la soluzione piu semplice è copiare il codice originale di gb.settings e inserirlo nel mio codice facendo le opportune modifiche
ma così mi semplifico troppo la vita.....

Citazione da: Akrobaticone - 06 Marzo 2021, 08:30:46

Il problema si verifica su raspberry a causa del journaling di ext4 e del ritardo con il quale vengono eseguite le scritture su SD
allego il progetto, ...

  hai allegato il mio esempio per vuott, se non ti spieghi meglio con il tuo esempio non sono in grado di aiutarti.
Ammesso e non concesso che una volta allegato il progetto tuo, poi io ne sia capace...

 

forse manca un pezzo che ho dato per scontato

Riepilogo meglio

Su raspberry a volte si verifica la corruzione del file .conf dove si salvano le configurazioni con settings
allora ho chiesto in mailing list e mi hanno confermato che alla chiusura dell'applicazione avviene in automatico il salvataggio della configurazione
Ipozizzando che il problema sia il ritardo con cui i file su ext4 con journaling e le scritture su sd e dal momento in cui alla chiusura dell'applicazione raspberry viene spento immediatamente anche in modi non "cristiani", ho tentato di creare una classe derivata da Settings  introducendo una variabile che blocca la scrittura del file .conf che avviene nella routine _free() della classe settings.
All'interno dell'applicazione ad ogni salvataggio che eseguo do immediatamente dopo il comando "sync" da shell per forzare la scrittura su disco che altrimenti viene posticipata.
Pensavo che derivando la classe con inherits e sovrascrivendo la funzione _free() la cosa potesse funzionare, ma così non avviene
Al contrario Gianluigi, nel tuo esempio funziona
quindi mi è venuta la curiosità di capire come funziona inherits in questi casi.
Il problema in se lo posso risolvere inserendo il codice originale di Setting con una piccola modifica evitando quindi di selezionare il componente gb.settings, ma voglio capirci di più
Spero questa volta di essere stato piu chiaro e di aver messo tutti i pezzi che prima mancavano

Per dovere di cronaca condivido la mia esperienza
Su ext4 con journaling se si cancella un file e immediatamente dopo si toglie tensione al successivo riavvio il suddetto file possiamo ritrovarcelo ancora vivo e vegeto anche se subito dopo la cancellazione non risulta più presente al sistema operativo
Ciò è piu evidente su raspberry poichè il disco è una SD e la scrittura è molto piu lenta che su un HD
Nel caso di settings a volte mi ritrovo un file .conf con dimensione 0
La mia applicazione deve superare anche questa prova e ci ho perso un po di tempo per capire quale fosse il problema


 

Derivando una classe con inherits posso usare tutti i metodi della classe genitrice facendo riferimenti con SUPER
ma non riesco a fare funzionare la cosa con i metodi nascosti


Come posso fare a creare un riferimento alla _free() della classe genitrice?

Dove sbaglio?

...la vince
https://www.dday.it/redazione/38579/lenovo-non-ha-rimborsato-il-costo-di-windows-ad-un-utente-che-voleva-linux-il-giudice-la-punisce-20000-euro-di-multa

Lo hanno tolto
https://www.lffl.org/2021/02/raspberry-pi-os-rimosso-repo-microsoft.html
C'è stata una mezza rivoluzione
A quanto pare nessuno si fida delle finestre