linemodel_load.m

function model = linemodel_load(filename)
% LINEMODEL_LOAD Load a LINE model (Network or LayeredNetwork) from JSON.
%
%   MODEL = LINEMODEL_LOAD(FILENAME) loads a model from the specified JSON
%   file (conforming to line-model.schema.json) and returns a Network or
%   LayeredNetwork object.
%
% Parameters:
%   filename - path to a .json file
%
% Returns:
%   model - Network or LayeredNetwork object
%
% Example:
%   model = linemodel_load('mm1.json');
%   solver = SolverMVA(model);
%   AvgTable = solver.getAvgTable();
%
% Copyright (c) 2012-2026, Imperial College London
% All rights reserved.
 
jsonText = fileread(filename);
doc = jsondecode(jsonText);
 
if ~isfield(doc, 'model')
    error('linemodel_load:noModel', 'JSON file does not contain a "model" field.');
end
 
data = doc.model;
mtype = data.type;
 
switch mtype
    case 'Network'
        model = json2network(data, jsonText);
    case 'LayeredNetwork'
        model = json2layered(data);
    otherwise
        error('linemodel_load:unknownType', 'Unsupported model type: %s', mtype);
end
end
 
 
% =========================================================================
%  Network deserialization
% =========================================================================
 
function model = json2network(data, rawJson)
% Reconstruct a Network from decoded JSON struct.
% rawJson is the original text, used for parsing routing keys with commas.
 
modelName = 'model';
if isfield(data, 'name')
    modelName = data.name;
end
model = Network(modelName);
 
% --- Create nodes (before classes, since ClosedClass needs refstat) ---
nodeList = {};
if isfield(data, 'nodes')
    nds = data.nodes;
    if isstruct(nds)
        nds = num2cell(nds);
    end
    for i = 1:length(nds)
        nd = nds{i};
        if isstruct(nd)
            nd_name = nd.name;
            nd_type = nd.type;
        else
            nd_name = nd('name');
            nd_type = nd('type');
        end
        node = create_node(model, nd, nd_name, nd_type);
        nodeList{end+1} = node; %#ok<AGROW>
    end
end
node_map = containers.Map();
for i = 1:length(nodeList)
    node_map(nodeList{i}.name) = nodeList{i};
end
 
% --- Deferred node linking (Fork/Join, Fork tasksPerLink) ---
if isfield(data, 'nodes')
    nds2 = data.nodes;
    if isstruct(nds2)
        nds2 = num2cell(nds2);
    end
    for i = 1:length(nds2)
        nd2 = nds2{i};
        nd_name2 = nd2.name;
        node2 = node_map(nd_name2);
        % Join: link to paired Fork
        if isfield(nd2, 'forkNode') && isa(node2, 'Join')
            if node_map.isKey(nd2.forkNode)
                node2.joinOf = node_map(nd2.forkNode);
            end
        end
        % Fork: set tasksPerLink
        if isfield(nd2, 'tasksPerLink') && isa(node2, 'Fork')
            node2.setTasksPerLink(nd2.tasksPerLink);
        end
    end
end
 
% --- Create classes ---
classesList = {};
if isfield(data, 'classes')
    cls = data.classes;
    if isstruct(cls)
        cls = num2cell(cls);
    end
    for i = 1:length(cls)
        cd = cls{i};
        cname = cd.name;
        ctype = cd.type;
        switch ctype
            case 'Open'
                prio = 0;
                if isfield(cd, 'priority'), prio = cd.priority; end
                jc = OpenClass(model, cname, prio);
            case 'Closed'
                pop = cd.population;
                refNode = [];
                if isfield(cd, 'refNode') && node_map.isKey(cd.refNode)
                    refNode = node_map(cd.refNode);
                end
                prio = 0;
                if isfield(cd, 'priority'), prio = cd.priority; end
                if isempty(refNode)
                    error('linemodel_load:noRefNode', ...
                        'ClosedClass "%s" has no valid refNode.', cname);
                end
                jc = ClosedClass(model, cname, pop, refNode, prio);
            otherwise
                jc = OpenClass(model, cname);
        end
        classesList{end+1} = jc; %#ok<AGROW>
    end
end
class_map = containers.Map();
for i = 1:length(classesList)
    class_map(classesList{i}.name) = classesList{i};
end
 
% --- Set service/arrival distributions ---
if isfield(data, 'nodes')
    nds = data.nodes;
    if isstruct(nds)
        nds = num2cell(nds);
    end
    for i = 1:length(nds)
        nd = nds{i};
        nd_name = nd.name;
        node = node_map(nd_name);
 
        if isfield(nd, 'service') && ~isempty(nd.service)
            svc = nd.service;
            svcFields = fieldnames(svc);
            for f = 1:length(svcFields)
                cname = svcFields{f};
                distJson = svc.(cname);
                if ~class_map.isKey(cname)
                    continue;
                end
                jc = class_map(cname);
                dist = json2dist(distJson);
                if ~isempty(dist)
                    if isa(node, 'Source')
                        node.setArrival(jc, dist);
                    elseif isa(node, 'Queue') || isa(node, 'Delay')
                        node.setService(jc, dist);
                    end
                end
            end
        end
 
        % ClassSwitch matrix (dict format: classSwitchMatrix)
        if isfield(nd, 'classSwitchMatrix') && isa(node, 'ClassSwitch')
            csm_data = nd.classSwitchMatrix;
            classes = model.getClasses();
            K = length(classes);
            mat = zeros(K);
            class_idx = containers.Map();
            for ci = 1:K
                class_idx(classes{ci}.name) = ci;
            end
            fromFields = fieldnames(csm_data);
            for fi = 1:length(fromFields)
                fromName = fromFields{fi};
                if ~class_idx.isKey(fromName), continue; end
                ri = class_idx(fromName);
                toStruct = csm_data.(fromName);
                toFields = fieldnames(toStruct);
                for ti = 1:length(toFields)
                    toName = toFields{ti};
                    if ~class_idx.isKey(toName), continue; end
                    ci = class_idx(toName);
                    mat(ri, ci) = toStruct.(toName);
                end
            end
            node.server = node.server.updateClassSwitch(mat);
        % Legacy 2D array format: csMatrix (from older JAR saves)
        elseif isfield(nd, 'csMatrix') && isa(node, 'ClassSwitch')
            mat = nd.csMatrix;
            if iscell(mat)
                mat = cell2mat(mat);
            end
            node.server = node.server.updateClassSwitch(mat);
        end
 
        % DPS scheduling parameters
        if isfield(nd, 'schedParams') && isa(node, 'Queue')
            sp = nd.schedParams;
            spFields = fieldnames(sp);
            for sfi = 1:length(spFields)
                cname = spFields{sfi};
                if class_map.isKey(cname)
                    jc = class_map(cname);
                    cidx = 0;
                    for ki = 1:length(classesList)
                        if strcmp(classesList{ki}.name, cname)
                            cidx = ki;
                            break;
                        end
                    end
                    if cidx > 0
                        node.schedStrategyPar(cidx) = sp.(cname);
                    end
                end
            end
        end
 
        % Cache hit/miss class mappings and popularity distributions
        if isa(node, 'Cache') && isfield(nd, 'cache')
            cc = nd.cache;
            % Hit class mapping
            if isfield(cc, 'hitClass')
                hcData = cc.hitClass;
                hcFields = fieldnames(hcData);
                for hci = 1:length(hcFields)
                    inName = hcFields{hci};
                    outName = hcData.(inName);
                    if class_map.isKey(inName) && class_map.isKey(outName)
                        node.setHitClass(class_map(inName), class_map(outName));
                    end
                end
            end
            % Miss class mapping
            if isfield(cc, 'missClass')
                mcData = cc.missClass;
                mcFields = fieldnames(mcData);
                for mci = 1:length(mcFields)
                    inName = mcFields{mci};
                    outName = mcData.(inName);
                    if class_map.isKey(inName) && class_map.isKey(outName)
                        node.setMissClass(class_map(inName), class_map(outName));
                    end
                end
            end
            % Popularity distributions (setRead)
            if isfield(cc, 'popularity')
                popData = cc.popularity;
                popFields = fieldnames(popData);
                for pfi = 1:length(popFields)
                    cname = popFields{pfi};
                    if class_map.isKey(cname)
                        popDist = json2dist(popData.(cname));
                        if ~isempty(popDist)
                            node.setRead(class_map(cname), popDist);
                        end
                    end
                end
            end
        end
    end
end
 
% --- Configure Transition modes ---
if isfield(data, 'nodes')
    nds3 = data.nodes;
    if isstruct(nds3)
        nds3 = num2cell(nds3);
    end
    for i = 1:length(nds3)
        nd3 = nds3{i};
        if ~isfield(nd3, 'modes'), continue; end
        if ~strcmp(nd3.type, 'Transition'), continue; end
        tnode = node_map(nd3.name);
        modesData = nd3.modes;
        if isstruct(modesData)
            modesData = num2cell(modesData);
        end
        for mi = 1:length(modesData)
            md = modesData{mi};
            modeName = 'Mode';
            if isfield(md, 'name'), modeName = md.name; end
            mode = tnode.addMode(modeName);
            % Distribution
            if isfield(md, 'distribution') && ~isempty(md.distribution)
                dist = json2dist(md.distribution);
                if ~isempty(dist)
                    tnode.setDistribution(mode, dist);
                end
            end
            % Timing strategy
            if isfield(md, 'timingStrategy')
                if strcmp(md.timingStrategy, 'IMMEDIATE')
                    tnode.setTimingStrategy(mode, TimingStrategy.IMMEDIATE);
                else
                    tnode.setTimingStrategy(mode, TimingStrategy.TIMED);
                end
            end
            % Number of servers
            if isfield(md, 'numServers') && md.numServers > 1
                tnode.setNumberOfServers(mode, md.numServers);
            end
            % Firing priority
            if isfield(md, 'firingPriority')
                tnode.setFiringPriorities(mode, md.firingPriority);
            end
            % Firing weight
            if isfield(md, 'firingWeight')
                tnode.setFiringWeights(mode, md.firingWeight);
            end
            % Enabling conditions
            if isfield(md, 'enablingConditions')
                ecList = md.enablingConditions;
                if isstruct(ecList), ecList = num2cell(ecList); end
                for ei = 1:length(ecList)
                    ec = ecList{ei};
                    if node_map.isKey(ec.node) && class_map.isKey(ec.class)
                        tnode.setEnablingConditions(mode, class_map(ec.class), node_map(ec.node), ec.count);
                    end
                end
            end
            % Inhibiting conditions
            if isfield(md, 'inhibitingConditions')
                icList = md.inhibitingConditions;
                if isstruct(icList), icList = num2cell(icList); end
                for ii = 1:length(icList)
                    ic = icList{ii};
                    if node_map.isKey(ic.node) && class_map.isKey(ic.class)
                        tnode.setInhibitingConditions(mode, class_map(ic.class), node_map(ic.node), ic.count);
                    end
                end
            end
            % Firing outcomes
            if isfield(md, 'firingOutcomes')
                foList = md.firingOutcomes;
                if isstruct(foList), foList = num2cell(foList); end
                for fi = 1:length(foList)
                    fo = foList{fi};
                    if node_map.isKey(fo.node) && class_map.isKey(fo.class)
                        tnode.setFiringOutcome(mode, class_map(fo.class), node_map(fo.node), fo.count);
                    end
                end
            end
        end
    end
end
 
% --- Build routing ---
if isfield(data, 'routing') && isfield(data.routing, 'type') && strcmp(data.routing.type, 'matrix')
    P = model.initRoutingMatrix();
    K = length(classesList);
    M = length(nodeList);
 
    % Build node/class index maps
    nodeIdx = containers.Map();
    for i = 1:M
        nodeIdx(nodeList{i}.name) = i;
    end
    classIdx = containers.Map();
    for i = 1:K
        classIdx(classesList{i}.name) = i;
    end
 
    % Parse routing keys from raw JSON to preserve commas
    routingEntries = parse_routing_keys(rawJson, class_map, node_map);
 
    for e = 1:length(routingEntries)
        re = routingEntries{e};
        r = classIdx(re.className1);
        s = classIdx(re.className2);
        ii = nodeIdx(re.fromNode);
        jj = nodeIdx(re.toNode);
        P{r,s}(ii, jj) = re.prob;
    end
 
    model.link(P);
end
end
 
 
function node = create_node(model, nd, name, ntype)
% Create a node from JSON data.
switch ntype
    case 'Source'
        node = Source(model, name);
    case 'Sink'
        node = Sink(model, name);
    case 'Delay'
        node = Delay(model, name);
    case 'Queue'
        schedStr = 'FCFS';
        if isfield(nd, 'scheduling')
            schedStr = nd.scheduling;
        end
        schedId = str_to_sched_id(schedStr);
        node = Queue(model, name, schedId);
        if isfield(nd, 'servers') && nd.servers > 1
            node.setNumberOfServers(nd.servers);
        end
        if isfield(nd, 'buffer') && isfinite(nd.buffer)
            node.cap = nd.buffer;
        end
    case 'Fork'
        node = Fork(model, name);
    case 'Join'
        node = Join(model, name);
    case 'Router'
        node = Router(model, name);
    case 'ClassSwitch'
        node = ClassSwitch(model, name);
    case 'Cache'
        cc = struct();
        if isfield(nd, 'cache')
            cc = nd.cache;
        end
        nitems = 10;
        if isfield(cc, 'items'), nitems = cc.items; end
        cap = 1;
        if isfield(cc, 'capacity'), cap = cc.capacity; end
        replStr = 'LRU';
        if isfield(cc, 'replacement'), replStr = cc.replacement; end
        replId = str_to_repl_id(replStr);
        node = Cache(model, name, nitems, cap, replId);
    case 'Place'
        node = Place(model, name);
    case 'Transition'
        node = Transition(model, name);
    otherwise
        node = Queue(model, name, SchedStrategy.FCFS);
end
end
 
 
% =========================================================================
%  LayeredNetwork deserialization
% =========================================================================
 
function model = json2layered(data)
% Reconstruct a LayeredNetwork from decoded JSON struct.
 
modelName = 'model';
if isfield(data, 'name')
    modelName = data.name;
end
model = LayeredNetwork(modelName);
 
% --- Processors ---
proc_map = containers.Map();
if isfield(data, 'processors')
    procs = data.processors;
    if isstruct(procs), procs = num2cell(procs); end
    for i = 1:length(procs)
        pd = procs{i};
        pname = pd.name;
        mult = 1;
        if isfield(pd, 'multiplicity'), mult = pd.multiplicity; end
        schedStr = 'INF';
        if isfield(pd, 'scheduling'), schedStr = pd.scheduling; end
        schedId = str_to_sched_id(schedStr);
        quantum = 0.001;
        if isfield(pd, 'quantum'), quantum = pd.quantum; end
        sf = 1.0;
        if isfield(pd, 'speedFactor'), sf = pd.speedFactor; end
        proc = Host(model, pname, mult, schedId, quantum, sf);
        if isfield(pd, 'replication') && pd.replication > 1
            proc.setReplication(pd.replication);
        end
        proc_map(pname) = proc;
    end
end
 
% --- Tasks ---
task_map = containers.Map();
if isfield(data, 'tasks')
    tsks = data.tasks;
    if isstruct(tsks), tsks = num2cell(tsks); end
    for i = 1:length(tsks)
        td = tsks{i};
        tname = td.name;
        mult = 1;
        if isfield(td, 'multiplicity'), mult = td.multiplicity; end
        schedStr = 'INF';
        if isfield(td, 'scheduling'), schedStr = td.scheduling; end
        schedId = str_to_sched_id(schedStr);
        task = Task(model, tname, mult, schedId);
        % Assign to processor
        if isfield(td, 'processor') && proc_map.isKey(td.processor)
            task.on(proc_map(td.processor));
        end
        % Think time
        if isfield(td, 'thinkTime')
            dist = json2dist(td.thinkTime);
            if ~isempty(dist)
                task.setThinkTime(dist);
            end
        end
        % Fan in
        if isfield(td, 'fanIn') && isstruct(td.fanIn)
            fnames = fieldnames(td.fanIn);
            for fi = 1:length(fnames)
                task.setFanIn(fnames{fi}, td.fanIn.(fnames{fi}));
            end
        end
        % Fan out
        if isfield(td, 'fanOut') && isstruct(td.fanOut)
            fnames = fieldnames(td.fanOut);
            for fi = 1:length(fnames)
                task.setFanOut(fnames{fi}, td.fanOut.(fnames{fi}));
            end
        end
        % Replication
        if isfield(td, 'replication') && td.replication > 1
            task.setReplication(td.replication);
        end
        task_map(tname) = task;
    end
end
 
% --- Entries ---
entry_map = containers.Map();
if isfield(data, 'entries')
    ents = data.entries;
    if isstruct(ents), ents = num2cell(ents); end
    for i = 1:length(ents)
        ed = ents{i};
        ename = ed.name;
        entry = Entry(model, ename);
        if isfield(ed, 'task') && task_map.isKey(ed.task)
            entry.on(task_map(ed.task));
        end
        entry_map(ename) = entry;
    end
end
 
% --- Activities ---
act_map = containers.Map();
if isfield(data, 'activities')
    acts = data.activities;
    if isstruct(acts), acts = num2cell(acts); end
    for i = 1:length(acts)
        ad = acts{i};
        aname = ad.name;
 
        % Host demand
        hd = GlobalConstants.FineTol;
        if isfield(ad, 'hostDemand')
            hdDist = json2dist(ad.hostDemand);
            if ~isempty(hdDist)
                hd = hdDist;
            end
        end
 
        % Bound to entry
        bte = '';
        if isfield(ad, 'boundTo')
            bte = ad.boundTo;
        end
 
        act = Activity(model, aname, hd, bte);
 
        % Assign to task
        if isfield(ad, 'task') && task_map.isKey(ad.task)
            act.on(task_map(ad.task));
        end
 
        % Replies to entry
        if isfield(ad, 'repliesTo') && entry_map.isKey(ad.repliesTo)
            act.repliesTo(entry_map(ad.repliesTo));
        end
 
        % Synch calls
        if isfield(ad, 'synchCalls')
            scs = ad.synchCalls;
            if isstruct(scs), scs = num2cell(scs); end
            for j = 1:length(scs)
                sc = scs{j};
                ename = sc.entry;
                meanCalls = 1.0;
                if isfield(sc, 'mean'), meanCalls = sc.mean; end
                if entry_map.isKey(ename)
                    act.synchCall(entry_map(ename), meanCalls);
                end
            end
        end
 
        % Asynch calls
        if isfield(ad, 'asynchCalls')
            acs = ad.asynchCalls;
            if isstruct(acs), acs = num2cell(acs); end
            for j = 1:length(acs)
                ac = acs{j};
                ename = ac.entry;
                meanCalls = 1.0;
                if isfield(ac, 'mean'), meanCalls = ac.mean; end
                if entry_map.isKey(ename)
                    act.asynchCall(entry_map(ename), meanCalls);
                end
            end
        end
 
        act_map(aname) = act;
    end
end
 
% --- Precedences ---
if isfield(data, 'precedences')
    precs = data.precedences;
    if isstruct(precs), precs = num2cell(precs); end
    for i = 1:length(precs)
        pd = precs{i};
        if ~isfield(pd, 'task') || ~task_map.isKey(pd.task)
            continue;
        end
        task = task_map(pd.task);
        ptype = pd.type;
        actNames = pd.activities;
        if ischar(actNames), actNames = {actNames}; end
 
        % Resolve activity names to objects
        actObjs = {};
        for ai = 1:length(actNames)
            an = actNames{ai};
            if act_map.isKey(an)
                actObjs{end+1} = act_map(an); %#ok<AGROW>
            end
        end
        if length(actObjs) < 2
            continue;
        end
 
        switch ptype
            case 'Serial'
                ap = ActivityPrecedence.Serial(actObjs{:});
                task.addPrecedence(ap);
            case 'AndFork'
                ap = ActivityPrecedence.AndFork(actObjs{1}, actObjs(2:end));
                task.addPrecedence(ap);
            case 'AndJoin'
                ap = ActivityPrecedence.AndJoin(actObjs(1:end-1), actObjs{end});
                task.addPrecedence(ap);
            case 'OrFork'
                probs = [];
                if isfield(pd, 'probabilities')
                    probs = pd.probabilities;
                    if isstruct(probs), probs = cell2mat(struct2cell(probs)); end
                end
                if isempty(probs)
                    n = length(actObjs) - 1;
                    probs = ones(1, n) / n;
                end
                ap = ActivityPrecedence.OrFork(actObjs{1}, actObjs(2:end), probs);
                task.addPrecedence(ap);
            case 'OrJoin'
                ap = ActivityPrecedence.OrJoin(actObjs(1:end-1), actObjs{end});
                task.addPrecedence(ap);
            case 'Loop'
                count = 1.0;
                if isfield(pd, 'loopCount'), count = pd.loopCount; end
                % Loop(preAct, postActs, counts)
                % preAct = first, loop body = middle, end = last
                if length(actObjs) >= 3
                    ap = ActivityPrecedence.Loop(actObjs{1}, actObjs(2:end-1), actObjs{end}, count);
                else
                    ap = ActivityPrecedence.Loop(actObjs{1}, actObjs(2:end), count);
                end
                task.addPrecedence(ap);
        end
    end
end
end
 
 
% =========================================================================
%  Distribution deserialization
% =========================================================================
 
function dist = json2dist(d)
% Convert a JSON distribution struct to a MATLAB Distribution object.
if isempty(d)
    dist = [];
    return;
end
 
dtype = d.type;
 
switch dtype
    case 'Disabled'
        dist = Disabled.getInstance();
        return;
    case 'Immediate'
        dist = Immediate.getInstance();
        return;
end
 
% Direct params
if isfield(d, 'params') && ~isempty(d.params)
    p = d.params;
    switch dtype
        case 'Exp'
            lam = p.lambda;
            dist = Exp(lam);
            return;
        case 'Det'
            dist = Det(p.value);
            return;
        case 'Erlang'
            dist = Erlang(p.lambda, p.k);
            return;
        case 'HyperExp'
            pv = p.p;
            lv = p.lambda;
            if isscalar(pv)
                dist = HyperExp(pv, lv(1), lv(2));
            else
                dist = HyperExp(pv(1), lv(1), lv(2));
            end
            return;
        case 'Gamma'
            dist = Gamma(p.alpha, p.beta);
            return;
        case 'Lognormal'
            dist = Lognormal(p.mu, p.sigma);
            return;
        case 'Uniform'
            dist = Uniform(p.a, p.b);
            return;
        case 'Zipf'
            dist = Zipf(p.s, p.n);
            return;
        case 'Pareto'
            dist = Pareto(p.alpha, p.scale);
            return;
        case 'DiscreteSampler'
            pv = p.p(:)';
            xv = p.x(:)';
            dist = DiscreteSampler(pv, xv);
            return;
    end
end
 
% PH representation
if isfield(d, 'ph') && ~isempty(d.ph)
    ph = d.ph;
    alpha = ph.alpha;
    T = ph.T;
    if ~isvector(alpha), alpha = alpha(:)'; end
    dist = PH(alpha, T);
    return;
end
 
% MAP representation
if isfield(d, 'map') && ~isempty(d.map)
    mapSpec = d.map;
    D0 = mapSpec.D0;
    D1 = mapSpec.D1;
    dist = MAP(D0, D1);
    return;
end
 
% Fit specification
if isfield(d, 'fit') && ~isempty(d.fit)
    fit = d.fit;
    method = fit.method;
    switch method
        case 'fitMean'
            m = fit.mean;
            switch dtype
                case 'Exp'
                    dist = Exp(1.0 / m);
                case 'Det'
                    dist = Det(m);
                otherwise
                    dist = Exp(1.0 / m);
            end
            return;
        case 'fitMeanAndSCV'
            m = fit.mean;
            scv = fit.scv;
            switch dtype
                case 'Erlang'
                    dist = Erlang.fitMeanAndSCV(m, scv);
                case 'HyperExp'
                    dist = HyperExp.fitMeanAndSCV(m, scv);
                otherwise
                    dist = Exp(1.0 / m);
            end
            return;
        case 'fitMeanAndOrder'
            m = fit.mean;
            order = fit.order;
            switch dtype
                case 'Erlang'
                    dist = Erlang.fitMeanAndOrder(m, order);
                otherwise
                    dist = Exp(1.0 / m);
            end
            return;
    end
end
 
% Fallback
dist = Exp(1.0);
end
 
 
% =========================================================================
%  Routing parser (handles comma keys in JSON)
% =========================================================================
 
function entries = parse_routing_keys(rawJson, class_map, node_map)
% Parse routing matrix from raw JSON text to handle keys with commas.
% Returns a cell array of structs with fields:
%   className1, className2, fromNode, toNode, prob
entries = {};
 
% Build reverse mapping: jsondecode-sanitized name -> original node name
% jsondecode uses matlab.lang.makeValidName which replaces spaces etc.
nodeNames = node_map.keys();
sanitized_map = containers.Map();
for ni = 1:length(nodeNames)
    origName = nodeNames{ni};
    sanitized = matlab.lang.makeValidName(origName);
    sanitized_map(sanitized) = origName;
end
 
classNames = class_map.keys();
 
% For each pair of class names, try to find the corresponding key in the JSON
for ri = 1:length(classNames)
    for si = 1:length(classNames)
        cn1 = classNames{ri};
        cn2 = classNames{si};
        keyStr = ['"', cn1, ',', cn2, '"'];
 
        % Find this key in the raw JSON
        pos = strfind(rawJson, keyStr);
        if isempty(pos)
            continue;
        end
 
        % For each occurrence, extract the nested from -> to -> prob structure
        for pidx = 1:length(pos)
            startPos = pos(pidx) + length(keyStr);
            % Skip whitespace and colon
            idx = startPos;
            while idx <= length(rawJson) && (rawJson(idx) == ' ' || rawJson(idx) == ':' || rawJson(idx) == newline || rawJson(idx) == char(13) || rawJson(idx) == char(9))
                idx = idx + 1;
            end
            if idx > length(rawJson) || rawJson(idx) ~= '{'
                continue;
            end
            % Extract the JSON object using brace counting
            objStr = extract_json_object(rawJson, idx);
            if isempty(objStr)
                continue;
            end
            % Parse the from -> to -> prob structure
            try
                fromTo = jsondecode(objStr);
                fromNames = fieldnames(fromTo);
                for fi = 1:length(fromNames)
                    fromField = fromNames{fi};
                    toStruct = fromTo.(fromField);
                    toNames = fieldnames(toStruct);
                    % Resolve sanitized field names back to original node names
                    if sanitized_map.isKey(fromField)
                        fromName = sanitized_map(fromField);
                    else
                        fromName = fromField;
                    end
                    for ti = 1:length(toNames)
                        toField = toNames{ti};
                        prob = toStruct.(toField);
                        if sanitized_map.isKey(toField)
                            toName = sanitized_map(toField);
                        else
                            toName = toField;
                        end
                        % Verify names exist in the model
                        if node_map.isKey(fromName) && node_map.isKey(toName)
                            re = struct();
                            re.className1 = cn1;
                            re.className2 = cn2;
                            re.fromNode = fromName;
                            re.toNode = toName;
                            re.prob = prob;
                            entries{end+1} = re; %#ok<AGROW>
                        end
                    end
                end
            catch
                % Skip if parsing fails
            end
        end
    end
end
end
 
 
function objStr = extract_json_object(str, startIdx)
% Extract a JSON object string starting at startIdx (must be '{').
if str(startIdx) ~= '{'
    objStr = '';
    return;
end
depth = 0;
inString = false;
escaped = false;
for i = startIdx:length(str)
    c = str(i);
    if escaped
        escaped = false;
        continue;
    end
    if c == '\'
        escaped = true;
        continue;
    end
    if c == '"'
        inString = ~inString;
        continue;
    end
    if ~inString
        if c == '{'
            depth = depth + 1;
        elseif c == '}'
            depth = depth - 1;
            if depth == 0
                objStr = str(startIdx:i);
                return;
            end
        end
    end
end
objStr = '';
end
 
 
% =========================================================================
%  Helper functions
% =========================================================================
 
function id = str_to_sched_id(str)
% Map scheduling string to SchedStrategy numeric ID.
switch upper(str)
    case 'INF',      id = SchedStrategy.INF;
    case 'FCFS',     id = SchedStrategy.FCFS;
    case 'LCFS',     id = SchedStrategy.LCFS;
    case 'LCFSPR',   id = SchedStrategy.LCFSPR;
    case 'PS',       id = SchedStrategy.PS;
    case 'DPS',      id = SchedStrategy.DPS;
    case 'GPS',      id = SchedStrategy.GPS;
    case 'SIRO',     id = SchedStrategy.SIRO;
    case 'RAND',     id = SchedStrategy.SIRO;  % alias
    case 'SJF',      id = SchedStrategy.SJF;
    case 'LJF',      id = SchedStrategy.LJF;
    case 'SEPT',     id = SchedStrategy.SEPT;
    case 'LEPT',     id = SchedStrategy.LEPT;
    case 'HOL',      id = SchedStrategy.HOL;
    case 'FCFSPRIO', id = SchedStrategy.FCFSPRIO;
    case 'FORK',     id = SchedStrategy.FORK;
    case 'EXT',      id = SchedStrategy.EXT;
    case 'REF',      id = SchedStrategy.REF;
    case 'POLLING',  id = SchedStrategy.POLLING;
    case 'PSPRIO',   id = SchedStrategy.PSPRIO;
    case 'DPSPRIO',  id = SchedStrategy.DPSPRIO;
    case 'GPSPRIO',  id = SchedStrategy.GPSPRIO;
    otherwise,       id = SchedStrategy.FCFS;
end
end
 
 
function id = str_to_repl_id(str)
% Map replacement strategy string to ReplacementStrategy numeric ID.
switch upper(str)
    case 'LRU',   id = ReplacementStrategy.LRU;
    case 'FIFO',  id = ReplacementStrategy.FIFO;
    case 'RR',    id = ReplacementStrategy.RR;
    case 'SFIFO', id = ReplacementStrategy.SFIFO;
    otherwise,     id = ReplacementStrategy.LRU;
end
end