有没有办法找到Matlab类的所有孩子？
Rat*_*ert 12 oop matlab subclass class-hierarchy
Matlab函数superclasses返回给定类的所有父项的名称.
是否有相当于找到从给定类派生的所有类,即子类？该函数allchild似乎仅限于图形句柄.
如果没有,可以采取什么策略来获得这样的清单？蛮力路径扫描是唯一的选择吗？
让我们把自己局限于Matlab路径中的类.
介绍:
在解决方案的过程中,我似乎找到了一个未记录的
meta.class类的静态方法,它返回所有缓存的类(几乎所有被调用时被删除的东西clear classes),并且(完全是偶然的)制作了一个检查classdef文件错误的工具.
因为我们想要找到所有子类,所以可靠的方法是制作所有已知类的列表,然后检查每个类是否来自任何其他类.为实现这一目标,我们将努力分为两类:
- " 批量类 " - 这里我们使用
what函数来制作一个文件列表,这些文件只是"铺设"在MATLAB路径上,它输出一个结构s(在what具有以下字段的文档中描述:'path' 'm' 'mlapp' 'mat' 'mex' 'mdl' 'slx' 'p' 'classes' 'packages'.然后我们将选择一些他们建立的类的列表.要识别.M或.P文件有什么样的内容(什么,我们关心的是类/非类),我们使用exist.通过洛伦证明在她的博客这个方法.在我的代码,这是mb_list. - " 包类 " - 这包括由MATLAB作为其内部包结构的一部分索引的类文件.获取此列表所涉及的算法涉及调用
meta.package.getAllPackages然后递归遍历此顶级包列表以获取所有子包.然后从每个包中提取类列表,并将所有列表连接成一个长列表 -mp_list.
该脚本有两个输入标志(includeBulkFiles,includePackages),用于确定每种类型的类是否应包含在输出列表中.
完整代码如下:
function [mc_list,subcls_list] = q37829489(includeBulkFiles,includePackages)
%% Input handling
if nargin < 2 || isempty(includePackages)
includePackages = false;
mp_list = meta.package.empty;
end
if nargin < 1 || isempty(includeBulkFiles)
includeBulkFiles = false;
mb_list = meta.class.empty; %#ok
% `mb_list` is always overwritten by the output of meta.class.getAllClasses;
end
%% Output checking
if nargout < 2
warning('Second output not assigned!');
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Get classes list from bulk files "laying around" the MATLAB path:
if includeBulkFiles
% Obtain MATLAB path:
p = strsplit(path,pathsep).';
if ~ismember(pwd,p)
p = [pwd;p];
end
nPaths = numel(p);
s = what; s = repmat(s,nPaths+20,1); % Preallocation; +20 is to accomodate rare cases
s_pos = 1; % where "what" returns a 2x1 struct.
for ind1 = 1:nPaths
tmp = what(p{ind1});
s(s_pos:s_pos+numel(tmp)-1) = tmp;
s_pos = s_pos + numel(tmp);
end
s(s_pos:end) = []; % truncation of placeholder entries.
clear p nPaths s_pos tmp
%% Generate a list of classes:
% from .m files:
m_files = vertcat(s.m);
% from .p files:
p_files = vertcat(s.p);
% get a list of potential class names:
[~,name,~] = cellfun(@fileparts,[m_files;p_files],'uni',false);
% get listed classes:
listed_classes = s.classes;
% combine all potential class lists into one:
cls_list = vertcat(name,listed_classes);
% test which ones are actually classes:
isClass = cellfun(@(x)exist(x,'class')==8,cls_list); %"exist" method; takes long
%[u,ia,ic] = unique(ext(isClass(1:numel(ext)))); %DEBUG:
% for valid classes, get metaclasses from name; if a classdef contains errors,
% will cause cellfun to print the reason using ErrorHandler.
[~] = cellfun(@meta.class.fromName,cls_list(isClass),'uni',false,'ErrorHandler',...
@(ex,in)meta.class.empty(0*fprintf(1,'The classdef for "%s" contains an error: %s\n'...
, in, ex.message)));
% The result of the last computation used to be assigned into mc_list, but this
% is no longer required as the same information (and more) is returned later
% by calling "mb_list = meta.class.getAllClasses" since these classes are now cached.
clear cls_list isClass ind1 listed_classes m_files p_files name s
end
%% Get class list from classes belonging to packages (takes long!):
if includePackages
% Get a list of all package classes:
mp_list = meta.package.getAllPackages; mp_list = vertcat(mp_list{:});
% see http://www.mathworks.com/help/matlab/ref/meta.package.getallpackages.html
% Recursively flatten package list:
mp_list = flatten_package_list(mp_list);
% Extract classes out of packages:
mp_list = vertcat(mp_list.ClassList);
end
%% Combine lists:
% Get a list of all classes that are in memory:
mb_list = meta.class.getAllClasses;
mc_list = union(vertcat(mb_list{:}), mp_list);
%% Map relations:
try
[subcls_list,discovered_classes] = find_superclass_relations(mc_list);
while ~isempty(discovered_classes)
mc_list = union(mc_list, discovered_classes);
[subcls_list,discovered_classes] = find_superclass_relations(mc_list);
end
catch ex % Turns out this helps....
disp(['Getting classes failed with error: ' ex.message ' Retrying...']);
[mc_list,subcls_list] = q37829489;
end
end
function [subcls_list,discovered_classes] = find_superclass_relations(known_metaclasses)
%% Build hierarchy:
sup_list = {known_metaclasses.SuperclassList}.';
% Count how many superclasses each class has:
n_supers = cellfun(@numel,sup_list);
% Preallocate a Subclasses container:
subcls_list = cell(numel(known_metaclasses),1); % should be meta.MetaData
% Iterate over all classes and
% discovered_classes = meta.class.empty(1,0); % right type, but causes segfault
discovered_classes = meta.class.empty;
for depth = max(n_supers):-1:1
% The function of this top-most loop was initially to build a hierarchy starting
% from the deepest leaves, but due to lack of ideas on "how to take it from here",
% it only serves to save some processing by skipping classes with "no parents".
tmp = known_metaclasses(n_supers == depth);
for ind1 = 1:numel(tmp)
% Fortunately, SuperclassList only shows *DIRECT* supeclasses. Se we
% only need to find the superclasses in the known classees list and add
% the current class to that list.
curr_cls = tmp(ind1);
% It's a shame bsxfun only works for numeric arrays, or else we would employ:
% bsxfun(@eq,mc_list,tmp(ind1).SuperclassList.');
for ind2 = 1:numel(curr_cls.SuperclassList)
pos = find(curr_cls.SuperclassList(ind2) == known_metaclasses,1);
% Did we find the superclass in the known classes list?
if isempty(pos)
discovered_classes(end+1,1) = curr_cls.SuperclassList(ind2); %#ok<AGROW>
% disp([curr_cls.SuperclassList(ind2).Name ' is not a previously known class.']);
continue
end
subcls_list{pos} = [subcls_list{pos} curr_cls];
end
end
end
end
% The full flattened list for MATLAB R2016a contains about 20k classes.
function flattened_list = flatten_package_list(top_level_list)
flattened_list = top_level_list;
for ind1 = 1:numel(top_level_list)
flattened_list = [flattened_list;flatten_package_list(top_level_list(ind1).PackageList)];
end
end
这个函数的输出是2个向量,在Java术语中可以被认为是Map<meta.class, List<meta.class>>:
mc_list- 类的对象向量meta.class,其中每个条目包含有关MATLAB已知的一个特定类的信息.这些是我们的"关键"Map.subcls_list- 一个(相当稀疏的)单元格向量,包含出现在相应位置的类的已知直接子类mc_list.这些是我们的"价值观",Map基本上是List<meta.class>.
一旦我们有了这两个列表,只需要找到你感兴趣的类的位置mc_list并从中获取它的子类列表subcls_list.如果需要间接子类,则对子类也重复相同的过程.
或者,可以使用例如logical sparse邻接矩阵来表示层次结构A,其中,i,j == 1表示该类i是其子类j.然后该矩阵的转置可以表示相反的关系,即,一个Ť I,J == 1个装置i是一个超类的j.记住adjaceny矩阵的这些属性可以非常快速地搜索和遍历层次结构(避免需要"昂贵的" meta.class对象比较).
几点说明:
- 由于原因未知(缓存？)代码可能由于错误(例如
Invalid or deleted object.)而失败,在这种情况下重新运行它会有所帮助.我添加了一个try/catch自动执行此操作的功能. - 代码中有2个实例,其中数组在循环内生长.这当然是不需要的,应该避免.由于缺乏更好的想法,代码就像这样.
- 如果算法的"发现"部分无法避免(通过某种方式首先找到所有类),则可以(并且应该)优化它,以便每次迭代仅对先前未知的类进行操作.
- 运行此代码的一个有趣的意外好处是它扫描所有已知
classdef的并报告其中的任何错误 - 对于任何使用MATLAB OOP的人来说,这可能是一个有用的工具,每隔一段时间运行一次 :) - 感谢@Suever提供了一些有用的指示.
与Oleg的方法比较:
为了将这些结果与Oleg的例子进行比较,我将在我的计算机上使用上述脚本的输出(包含~20k类; 在此处作为.mat文件上传).然后我们可以通过以下方式访问类映射:
hRoot = meta.class.fromName('sde');
subcls_list{mc_list==hRoot}
ans =
class with properties:
Name: 'sdeddo'
Description: ''
DetailedDescription: ''
Hidden: 0
Sealed: 0
Abstract: 0
Enumeration: 0
ConstructOnLoad: 0
HandleCompatible: 0
InferiorClasses: {0x1 cell}
ContainingPackage: [0x0 meta.package]
PropertyList: [9x1 meta.property]
MethodList: [18x1 meta.method]
EventList: [0x1 meta.event]
EnumerationMemberList: [0x1 meta.EnumeratedValue]
SuperclassList: [1x1 meta.class]
subcls_list{mc_list==subcls_list{mc_list==hRoot}} % simulate recursion
ans =
class with properties:
Name: 'sdeld'
Description: ''
DetailedDescription: ''
Hidden: 0
Sealed: 0
Abstract: 0
Enumeration: 0
ConstructOnLoad: 0
HandleCompatible: 0
InferiorClasses: {0x1 cell}
ContainingPackage: [0x0 meta.package]
PropertyList: [9x1 meta.property]
MethodList: [18x1 meta.method]
EventList: [0x1 meta.event]
EnumerationMemberList: [0x1 meta.EnumeratedValue]
SuperclassList: [1x1 meta.class]
在这里,我们可以看到,去年产量只有1级(sdeld),当我们期待他们的3( ,sdeld,sdemrd)heston -这意味着一些类缺少从这个名单1.
相反,如果我们检查一个共同的父类,例如handle,我们会看到完全不同的图片:
subcls_list{mc_list==meta.class.fromName('handle')}
ans =
1x4059 heterogeneous class (NETInterfaceCustomMetaClass, MetaClassWithPropertyType, MetaClass, ...) array with properties:
Name
Description
DetailedDescription
Hidden
Sealed
Abstract
Enumeration
ConstructOnLoad
HandleCompatible
InferiorClasses
ContainingPackage
PropertyList
MethodList
EventList
EnumerationMemberList
SuperclassList
用几个词来概括:这个方法试图索引MATLAB路径上的所有已知类.构建类列表/索引需要几分钟,但这是一次性过程,以后在搜索列表时可以获得回报.它似乎错过了一些类,但找到的关系不限于相同的包,路径等.因此它本身支持多重继承.
1 - 我目前不知道是什么原因引起的.
代码
我将代码移动到Github存储库getSubclasses上,因为它超过200行.欢迎您提供reqeut功能和发布错误报告.
理念
给定一个根类名或一个meta.class文件夹路径,它将遍历文件夹结构并构建一个包含从根(无限深度)派生的所有子类的图.如果未提供路径,则它将从根类所在的文件夹中向下递归.
请注意,解决方案是本地的,这就是它快速的原因,并且依赖于子类嵌套在所选路径的某个子文件夹下的假设.
例
列出sde该类的所有子类.您将需要R2015b才能生成图形,或者您可以使用输出和FEX提交plot_graph()来生成依赖图.
getSubclasses('sde','C:\Program Files\MATLAB\R2016a\toolbox\finance\finsupport')
并且边缘和节点名称的输出:
names from to
________ ____ __
'sde' 1 1
'bm' 2 3
'sdeld' 3 6
'cev' 4 3
'gbm' 5 4
'sdeddo' 6 1
'heston' 7 6
'cir' 8 9
'sdemrd' 9 6
'hwv' 10 9
我们可以将结果与官方文档进行比较,在本例中列出了SDE层次结构,即
定时
在Win7 64b R2016a上
- 不到0.1秒:
getSubclasses('sde','C:\Program Files\MATLAB\R2016a\toolbox\finance\finsupport') - 扫描整个matlabroot 约13秒:
getSubclasses('sde',matlabroot);
这不是一个完整的解决方案，但是，您可以将.m路径中的所有文件解析为文本，并使用正则表达式来查找子类定义。
就像是^\s*classdef\s*(\w*)\s*<\s*superClassName\s*(%.*)?
请注意，对于任何使用任何花哨的子类定义（例如eval.