È possibile nascondere i metodi ereditati dalla classe handle in matlab?

Question

Sto lavorando ad un'applicazione a riga di comando per la simulazione ad ultrasuoni in MATLAB. Quasi ogni oggetto nel nostro codice è una sottoclasse di handle (da passare come riferimenti). Il problema che sto avendo è che tutti i metodi ereditati dalla classe handle vengono mostrati nella sezione "Metodi" in MATLAB (vedi esempio sotto).

Quello che voglio è nascondere i metodi ereditati dalla classe handle in modo che solo la funzione che l'utente è autorizzato a utilizzare sia mostrata sotto "Metodi". In questo modo non sembra così disordinato per l'utente se lui/lei vuole sapere quali metodi usare.

Esempio class Test:

classdef Test < handle 
    methods 
     function myFunction(obj) 
     end 
    end 
end 

Nella riga di comando:

T = Test() 

T = 

    Test handle with no properties. 
    Methods, Events, Superclasses 

Dopo aver cliccato su "Metodi":

Methods for class Test: 

Test   delete  findobj  ge   isvalid  lt   ne   
addlistener eq   findprop  gt   le   myFunction notify 

quello che voglio:

Methods for class Test: 

Test   myFunction 

E 'possibile in MATLAB?

Answer 1

C'è una soluzione here, incluso il codice di esempio.

In breve, ciò che devi fare è di sovraccaricare la funzione built-in di Matlab methods, in modo che quando viene chiamato tua classe, rimuove i metodi di handle dall'uscita. Assicurati che funzioni su qualsiasi altra cosa, in modo da non rovinare l'altro codice dell'utente. Se non si utilizza la variante @foldername per memorizzare la classe, è possibile inserirla in una directory private, ad esempio.

Answer 2

Non è una soluzione completa, ma se lo si fa methods(T, '-full'), allora almeno ti dice quali metodi sono ereditati dall'handle, quindi sai cosa ignorare.

Answer 3

Se si sovraccaricano tutti i metodi della sottoclasse in un blocco di metodi nascosti, penso che farà esattamente ciò che si sta cercando.

Non sono sicuro di quali versioni di Matlab funzioni, ma sicuramente funziona per me in R2012b.

L'eccezione è isvalid poiché è sigillata in modo che non sia possibile sostituirla in una sottoclasse di handle.

classdef handle_light < handle 
    methods(Hidden) 
     function lh = addlistener(varargin) 
     lh = addlistener@handle(varargin{:}); 
     end 
     function notify(varargin) 
     notify@handle(varargin{:}); 
     end 
     function delete(varargin) 
     delete@handle(varargin{:}); 
     end 
     function Hmatch = findobj(varargin) 
     Hmatch = findobj@handle(varargin{:}); 
     end 
     function p = findprop(varargin) 
     p = findprop@handle(varargin{:}); 
     end 
     function TF = eq(varargin) 
     TF = eq@handle(varargin{:}); 
     end 
     function TF = ne(varargin) 
     TF = ne@handle(varargin{:}); 
     end 
     function TF = lt(varargin) 
     TF = lt@handle(varargin{:}); 
     end 
     function TF = le(varargin) 
     TF = le@handle(varargin{:}); 
     end 
     function TF = gt(varargin) 
     TF = gt@handle(varargin{:}); 
     end 
     function TF = ge(varargin) 
     TF = ge@handle(varargin{:}); 
     end 
     function TF = isvalid(varargin) 
     TF = isvalid@handle(varargin{:}); 
     end 
    end 
end 

Se si salva la classe sopra per handle_light.m e quindi digitare methods handle_light nella finestra di comando si otterrà il seguente risultato:

Methods for class handle_light: 

handle_light isvalid 

La classe test diventa quindi:

classdef Test < handle_light 
    methods 
     function myFunction(obj) 
     end 
    end 
end 

Facendolo in questo modo significa che non è necessario inserire i sovraccarichi nella classe Test che mantiene le cose in ordine.

Answer 4

Basta ottenere le funzioni dalla classe ereditata e annullarle con quelle della classe principale utilizzando setdiff.

mH = methods('handle'); 
m = methods('MyClass'); 

m = setdiff(m,mH);