有没有办法找到Matlab类的所有孩子？

时间：2016-06-15 08:02:25

标签： matlab oop subclass class-hierarchy

Matlab函数superclasses返回给定类的所有父项的名称。

是否有相当于从给定的类即。子类中查找所有类派生的？函数allchild似乎仅限于图形句柄。

如果没有，可以采取什么策略来获得这样的清单？蛮力路径扫描是唯一的选择吗？

让我们将自己限制在Matlab的路径中。

3 个答案:

答案 0 :(得分：7)

  

说明：

     

在解决方案的过程中，我似乎找到了meta.class类的未记录的静态方法，该方法返回所有缓存的类（当有人调用clear classes时，几乎所有被删除的内容）以及（完全是偶然的）制作了一个检查classdef文件错误的工具。

由于我们想要找到 所有 子类，所以可靠的方法是列出 所有已知的 类，然后检查每个类是否来自任何其他类。为实现这一目标，我们将努力分为两类：

  • ＆＃34; 批量课程＆＃34; - 在这里，我们使用what函数来制作一个文件列表，这些文件只是＆＃34;铺设＆＃34;在MATLAB路径上，输出结构s（在what的文档中描述，具有以下字段：'path' 'm' 'mlapp' 'mat' 'mex' 'mdl' 'slx' 'p' 'classes' 'packages'。然后我们将选择其中一些来构建类列表。要确定.m或.p文件的内容类型（我们关心的是class / not-class），我们使用exist。This method is demonstrated by Loren in her blog。我的代码，这是mb_list。
  • ＆＃34; 套餐类＆＃34; - 这包括由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已知的一个特定类的信息。这些是＆＃34;键＆＃34;我们的Map。
  • subcls_list - 一个（相当稀疏的）单元格向量，包含出现在mc_list对应位置的类的已知直接子类。这些是＆＃34;值＆＃34;我们的Map，基本上是List<meta.class>。

一旦我们拥有这两个列表，只需要在mc_list中找到您感兴趣的类别的位置并从subcls_list获取其子类列表。如果需要间接子类，则对子类也重复相同的过程。

或者，可以使用例如表示层次结构。 logical sparse邻接矩阵A，其中 a i，j == 1 表示类i是j的子类。然后，这个矩阵的转置可以表示相反的关系，即 a T i，j == 1 表示i是j的超级类。记住adjaceny矩阵的这些属性可以非常快速地搜索和遍历层次结构（避免了对meta.class对象的昂贵＆＃34;比较）。

几点说明：

  • 由于原因未知（缓存？），代码可能会因错误而失败（例如Invalid or deleted object.），在这种情况下重新运行它会有所帮助。我添加了try/catch自动执行此操作。
  • 代码中有2个实例，其中数组在循环内生长。这当然是不需要的，应该避免。由于缺乏更好的想法，代码就像这样。
  • 如果＆＃34;发现＆＃34;部分算法无法避免（通过某种方式首先找到所有类），人们可以（并且应该）对其进行优化，以便每次迭代仅对以前未知的类进行操作。
  • 运行此代码的一个有趣的无意识的好处是它扫描所有已知的classdef并报告其中的任何错误 - 这可以是每次运行一次的有用工具对于任何使用MATLAB OOP的人来说，有一段时间：）
  • 感谢@Suever提供了一些有用的指示。

与Oleg的方法比较：

为了将这些结果与Oleg的例子进行比较，我将在我的计算机上使用上述脚本的输出（包含~20k类;上传here作为.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 - 我目前不知道是什么原因引起的。

答案 1 :(得分：5)

代码

我移动了代码，因为它是＆gt; 200行到Github存储库getSubclasses。欢迎您使用reqeut功能并发布错误报告。

观

给定一个 root 类名或meta.class和一个文件夹路径，它将遍历文件夹结构并构建一个包含从根源派生的所有子类的图形（无限深度） ）。如果未提供路径，则它将从根类所在的文件夹中向下递归。

请注意，解决方案是本地的，这就是它快速的原因，并且依赖于子类嵌套在所选路径的某个子文件夹下的假设。

实施例

列出sde类的所有子类。您将需要R2015b才能生成图形，或者您可以使用输出和FEX提交plot_graph()来生成依赖图。

getSubclasses('sde','C:\Program Files\MATLAB\R2016a\toolbox\finance\finsupport')

enter image description here

带边和节点名的输出：

 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 hierarchy，即

enter image description here

时序

在Win7 64b R2016a上

  • 小于 0.1秒：getSubclasses('sde','C:\Program Files\MATLAB\R2016a\toolbox\finance\finsupport')
    • 如果扫描整个matlabroot，则
  • 约 13秒：getSubclasses('sde',matlabroot);

答案 2 :(得分：0)

不是一个完整的解决方案，但是，您可以将路径中的所有.m文件解析为文本，并使用正则表达式查找子类定义。

像^\s*classdef\s*(\w*)\s*<\s*superClassName\s*(%.*)?

这样的东西

请注意，此将在任何使用任何花哨的子类定义上静默失败，例如eval。

相关问题
最新问题