function obj = jsonpath(root, jpath, varargin)

obj = root;

jpath = regexprep(jpath, '([^.\]])(\[[-0-9:\*]+\])', '$1.$2');

jpath = regexprep(jpath, '\[[''"]*([^\]''"]+)[''"]*\]', '.[$1]');

jpath = regexprep(jpath, '\\\.', '_0x2E_');

while (regexp(jpath, '(\[[''"]*[^\]''"]+)\.(?=[^\]''"]+[''"]*\])'))

jpath = regexprep(jpath, '(\[[''"]*[^\]''"]+)\.(?=[^\]''"]+[''"]*\])', '$1_0x2E_');

[pat, paths] = regexp(jpath, '(\.{0,2}[^\.]+)', 'match', 'tokens');

if (~isempty(pat) && ~isempty(paths))

if (strcmp(paths{1}, '$'))

paths(1) = [];

end

if (isempty(varargin))

for i = 1:length(paths)

[obj, isfound] = getonelevel(obj, paths, i, varargin{:});

if (~isfound)

return

end

end

else

datastack = cell(1, length(paths) + 1);

datastack{1} = obj;

for i = 1:length(paths)

[datastack{i + 1}, isfound] = getonelevel(datastack{i}, paths, i, varargin{:});

if (~isfound)

error(['data with a jsonpath ' jpath ' does not exist']);

end

end

fieldname = paths{end}{1}(2:end);

datastack{end - 1} = setfield_safe(datastack{end - 1}, fieldname, varargin{1});

for i = length(paths) - 1:-1:1

fieldname = paths{i}{1}(2:end);

datastack{i} = setfield_safe(datastack{i}, fieldname, datastack{i + 1});

end

obj = datastack{1};

end

function [obj, isfound] = getonelevel(input, paths, pathid, varargin)

pathname = paths{pathid};

if (iscell(pathname))

pathname = pathname{1};

deepscan = ~isempty(regexp(pathname, '^\.\.', 'once'));

origpath = pathname;

pathname = regexprep(pathname, '^\.+', '');

if (strcmp(pathname, '$'))

obj = input;

elseif (regexp(pathname, '$\d+'))

obj = input(str2double(pathname(2:end)) + 1);

elseif (~isempty(regexp(pathname, '^\[[-0-9\*:]+\]$', 'once')) || iscell(input))

arraystr = pathname(2:end - 1);

if (find(arraystr == ':'))

arrayrange = regexp(arraystr, '(?<start>-*\d*):(?<end>-*\d*)', 'names');

if (~isempty(arrayrange.start))

arrayrange.start = str2double(arrayrange.start);

arrayrange.start = (arrayrange.start < 0) * length(input) + arrayrange.start + 1;

else

arrayrange.start = 1;

end

if (~isempty(arrayrange.end))

arrayrange.end = str2double(arrayrange.end);

arrayrange.end = (arrayrange.end < 0) * length(input) + arrayrange.end + 1;

else

arrayrange.end = length(input);

end

elseif (regexp(arraystr, '^[-0-9:]+', 'once'))

firstidx = str2double(arraystr);

if (firstidx < 0)

firstidx = length(input) + firstidx + 1;

else

firstidx = firstidx + 1;

end

arrayrange.start = firstidx;

arrayrange.end = firstidx;

elseif (~isempty(regexp(arraystr, '^\*', 'once')))

% do nothing

end

if (exist('arrayrange', 'var'))

obj = {input(arrayrange.start:arrayrange.end)};

else

arrayrange = struct('start', 1, 'end', length(input));

end

if (~exist('obj', 'var') && iscell(input))

input = {input{arrayrange.start:arrayrange.end}};

if (deepscan)

searchkey = ['..' pathname];

else

searchkey = origpath;

end

for idx = 1:length(input)

[val, isfound] = getonelevel(input{idx}, [paths{1:pathid - 1} {searchkey}], pathid);

if (isfound)

if (~exist('newobj', 'var'))

newobj = {};

end

newobj = [newobj(:)', val(:)'];

end

end

if (exist('newobj', 'var'))

obj = newobj;

end

if (exist('obj', 'var') && iscell(obj) && length(obj) == 1)

obj = obj{1};

end

else

obj = input(arrayrange.start:arrayrange.end);

end

elseif (isstruct(input) || isa(input, 'containers.Map') || isa(input, 'table') || isa(input, 'jdict'))

pathname = regexprep(pathname, '^\[(.*)\]$', '$1');

stpath = encodevarname(pathname);

if (isstruct(input))

if (isfield(input, stpath))

obj = {input.(stpath)};

end

elseif (isa(input, 'table'))

if (any(ismember(input.Properties.VariableNames, stpath)))

obj = {input.(stpath)};

end

else

if (isKey(input, pathname))

obj = {input(pathname)};

elseif (isKey(input, decodevarname(pathname)))

obj = {input(decodevarname(pathname))};

end

end

if (~exist('obj', 'var') || deepscan)

if (isa(input, 'containers.Map'))

items = keys(input);

else

items = fieldnames(input);

end

for idx = 1:length(items)

if (isa(input, 'containers.Map'))

[val, isfound] = getonelevel(input(items{idx}), [paths{1:pathid - 1} {['..' pathname]}], pathid);

elseif (isa(input, 'table'))

[val, isfound] = getonelevel({input.(items{idx})}, [paths{1:pathid - 1} {['..' pathname]}], pathid);

elseif (isstruct(input) && length(input) > 1) % struct array

[val, isfound] = getonelevel({input.(items{idx})}, [paths{1:pathid - 1} {['..' pathname]}], pathid);

else

[val, isfound] = getonelevel(input.(items{idx}), [paths{1:pathid - 1} {['..' pathname]}], pathid);

end

if (isfound)

if (~exist('obj', 'var'))

obj = {};

end

if (iscell(val))

obj = [obj(:)', val(:)'];

else

obj = [obj(:)', {val}];

end

end

end

if (exist('obj', 'var') && length(obj) == 1)

obj = obj{1};

end

end

if (exist('obj', 'var') && iscell(obj) && length(obj) == 1)

obj = obj{1};

end

elseif (~deepscan)

error('json path segment "%s" can not be found in the input object\n', pathname);

if (~exist('obj', 'var'))

isfound = false;

obj = [];

elseif (nargout > 1)

isfound = true;

function data = setfield_safe(data, fieldname, value)

if (isa(value, 'jdict') && ~isempty(value{'kind'}) && strcmp(value{'kind'}, '_deleted_'))

if isstruct(data) && isfield(data, fieldname)

data = rmfield(data, fieldname);

elseif (isa(data, 'containers.Map') || isa(data, 'dictionary')) && isKey(data, fieldname)

data = remove(data, fieldname);

else

idx = struct('type', '.', 'subs', fieldname);

data = subsasgn(data, idx, []);

end

if isstruct(data)

data.(fieldname) = value;

elseif isa(data, 'containers.Map') || isa(data, 'dictionary')

data(fieldname) = value;

else

idx = struct('type', '.', 'subs', fieldname);

data = subsasgn(data, idx, value);

end