source: trunk/src/@xmltree/find.m @ 910

function list = find(varargin)
% XMLTREE/FIND Find elements in a tree with specified characteristics
% FORMAT list = find(varargin)
%
% tree  - XMLTree object
% xpath - string path with specific grammar (XPath)
% uid   - lists of root uid's
% parameter/value - pair of pattern
% list  - list of uid's of matched elements
%
%      list = find(tree,xpath)
%      list = find(tree,parameter,value[,parameter,value])
%      list = find(tree,uid,parameter,value[,parameter,value])
%
% Grammar for addressing parts of an XML document: 
%        XML Path Language XPath (http://www.w3.org/TR/xpath)
% Example: /element1//element2[1]/element3[5]/element4
%_______________________________________________________________________
%
% Find elements in an XML tree with specified characteristics or given
% a path (using a subset of XPath language).
%_______________________________________________________________________
% @(#)find.m                 Guillaume Flandin                 01/10/29

% TODO:
%   - clean up subroutines
%   - find should only be documented using XPath (other use is internal)
%   - handle '*', 'last()' in [] and '@'
%   - if a key is invalid, should rather return [] than error ?

if nargin==0
        error('[XMLTree] A tree must be provided');
elseif nargin==1
        list = 1:length(tree.tree);
        return
elseif mod(nargin,2)
        list = sub_find_subtree1(varargin{1}.tree,root(tree),varargin{2:end});
elseif isa(varargin{2},'double') & ...
           ndims(varargin{2}) == 2 & ...
           min(size(varargin{2})) == 1
        list = unique(sub_find_subtree1(varargin{1}.tree,varargin{2:end}));
elseif nargin==2 & ischar(varargin{2})
        list = sub_pathfinder(varargin{:});
else
   error('[XMLTree] Arguments must be parameter/value pairs.');
end

%=======================================================================
function list = sub_find_subtree1(varargin)
        list = [];
        for i=1:length(varargin{2})
                res = sub_find_subtree2(varargin{1},...
                                varargin{2}(i),varargin{3:end});
                list = [list res];
        end

%=======================================================================
function list = sub_find_subtree2(varargin)
        uid = varargin{2};
        list = [];
        if sub_comp_element(varargin{1}{uid},varargin{3:end})
                list = [list varargin{1}{uid}.uid];
        end
        if isfield(varargin{1}{uid},'contents')
                list = [list sub_find_subtree1(varargin{1},...
                        varargin{1}{uid}.contents,varargin{3:end})];
        end

%=======================================================================
function match = sub_comp_element(varargin)
match = 0;
try,
        % v = getfield(varargin{1}, varargin{2}); % slow...
        for i=1:floor(nargin/2)
                v = subsref(varargin{1}, struct('type','.','subs',varargin{i+1}));     
                if strcmp(v,varargin{i+2})
                        match = 1;
                end
        end
catch,
end

% More powerful but much slower
%match = 0;
%for i=1:length(floor(nargin/2)) % bug: remove length !!!
%   if isfield(varargin{1},varargin{i+1})
%         if ischar(getfield(varargin{1},varargin{i+1})) & ischar(varargin{i+2})
%          if strcmp(getfield(varargin{1},varargin{i+1}),char(varargin{i+2}))
%                       match = 1;
%                end
%         elseif isa(getfield(varargin{1},varargin{i+1}),'double') & ...
%                       isa(varargin{i+2},'double')
%                if getfield(varargin{1},varargin{i+1}) == varargin{i+2}
%                       match = 1;
%               end
%        else 
%               warning('Cannot compare different objects');
%         end
%   end
%end

%=======================================================================
function list = sub_pathfinder(tree,pth)
        %- Search for the delimiter '/' in the path
        i = findstr(pth,'/');
        %- Begin search by root
        list = root(tree);
        %- Walk through the tree
        j = 1;
        while j <= length(i)
                %- Look for recursion '//'
                if j<length(i) & i(j+1)==i(j)+1
                        recursive = 1;
                        j = j + 1;
                else
                        recursive = 0;
                end
                %- Catch the current tag 'element[x]'
                if j ~= length(i)
                        element = pth(i(j)+1:i(j+1)-1);
                else
                        element = pth(i(j)+1:end);
                end
                %- Search for [] brackets
                k = xml_findstr(element,'[',1,1);
                %- If brackets are present in current element
                if ~isempty(k)
                        l   = xml_findstr(element,']',1,1);
                        val = str2num(element(k+1:l-1));
                        element = element(1:k-1);
                end
                %- Use recursivity
                if recursive
                        list = find(tree,list,'name',element);
                %- Just look at children
                else
                        if i(j)==1 % if '/root/...' (list = root(tree) in that case)
                                if sub_comp_element(tree.tree{list},'name',element)
                                        % list = 1; % list still contains root(tree)
                                else
                                        list = [];
                                        return;
                                end
                        else
                                list = sub_findchild(tree,list,element);
                        end
                end
                % If an element is specified using a key
                if ~isempty(k)
                        if val < 1 | val > length(list)+1
                                error('[XMLTree] Bad key in the path.');
                        elseif val == length(list)+1
                                list = [];
                                return;
                        end
                        list = list(val);
                end
                if isempty(list), return; end
                j = j + 1;
        end
        
%=======================================================================
function list = sub_findchild(tree,listt,elmt)
        list = [];
        for a=1:length(listt)
                for b=1:length(tree.tree{listt(a)}.contents)
                        if sub_comp_element(tree.tree{tree.tree{listt(a)}.contents(b)},'name',elmt)
                                list = [list tree.tree{tree.tree{listt(a)}.contents(b)}.uid];
                        end
                end
        end