sn_contract.h

Go to the documentation of this file.

/*
 * Copyright (c) 2012-2026, QORE Lab, Imperial College London
 * All rights reserved.
 */
#ifndef LINE_API_SN_SN_CONTRACT_H
#define LINE_API_SN_SN_CONTRACT_H
 
/**
 * @file
 * @ingroup api_sn
 * The NetworkStruct contract: every field a NetworkStruct may carry, keyed by
 * its MATLAB name, and the field view of a struct that the contract validator
 * (sn_validate_contract.h) checks against it.
 *
 * GENERATED by doc/generate-sn-contract.py from doc/line-sn-contract.json. Do not edit.
 *
 * This struct is OBJECT-SHAPED: many MATLAB fields live on the Station, JobClass
 * and NodeDef records or are derived by an accessor. `via` says where each one
 * is: a data member, a const method, or a member of every station / class /
 * node record collected in index order. A field this port does not store has an
 * empty `via` and `absent` says why.
 */
 
#include <array>
#include <string>
 
#include "line/api/sn/sn_field_view.h"
#include "line/lang/qn/network_struct.h"
 
namespace line {
namespace api {
 
/** One NetworkStruct field; kinds and shapes are comma-separated. */
struct SnContractField {
    const char* name;    ///< the MATLAB name
    const char* group;   ///< "required" or "derived"
    const char* via;     ///< member, method, station, class, node; "" when absent
    const char* cpp;     ///< the member or method that carries it here
    const char* kinds;   ///< admissible sn_field_kind() values
    const char* shapes;  ///< admissible shapes of a non-empty value
    const char* absent;  ///< why this port does not store it; "" when it does
};
 
inline const std::array<SnContractField, 127>& sn_contract() {
    static const std::array<SnContractField, 127> fields = {{
        {"arrivalbatch", "required", "station", "arrival_batch", "vector", "MxK?", ""},
        {"balkingStrategy", "required", "station", "balking", "vector", "MxK?", ""},
        {"balkingThresholds", "required", "station", "balking", "vector", "MxK?", ""},
        {"batchRejectProb", "required", "station", "batch_reject", "vector", "MxK?", ""},
        {"breakdownMu", "required", "member", "breakdownparam", "map", "M?", ""},
        {"breakdownProc", "required", "member", "breakdownparam", "map", "M?", ""},
        {"cap", "required", "member", "cap", "vector", "M", ""},
        {"cdscaling", "required", "station", "cdscaling", "function", "M", ""},
        {"cdscalingpeak", "required", "station", "cdscalingpeak", "vector", "MxK?", ""},
        {"chains", "required", "member", "chains", "vector", "CxK", ""},
        {"classcap", "required", "member", "classcap", "vector", "MxK", ""},
        {"classdeadline", "required", "class", "deadline", "scalar", "K", ""},
        {"classnames", "required", "class", "name", "string", "K", ""},
        {"classprio", "required", "class", "prio", "scalar", "K", ""},
        {"classspawn", "required", "class", "spawn", "scalar", "K", ""},
        {"connmatrix", "required", "method", "connmatrix", "Matrix", "NxN", ""},
        {"csmask", "required", "member", "csmask", "vector", "KxK", ""},
        {"ctmcmapc", "derived", "member", "ctmcmapc", "map", "", ""},
        {"downServiceRates", "required", "member", "breakdownparam", "map", "M?", ""},
        {"droprule", "required", "member", "droprule", "vector", "MxK", ""},
        {"fj", "required", "member", "fj", "vector", "*", ""},
        {"fjauxclass", "required", "member", "fjauxclass", "vector", "K", ""},
        {"fjclassmap", "required", "member", "fjclassmap", "vector", "", ""},
        {"fjsync", "required", "", "", "", "", "carried by the FJ tag-augmented companion struct (FjTag.fjsync in lang/qn/fj_tag.h), not by NetworkStruct"},
        {"gdscaling", "required", "member", "gdscaling", "function", "", ""},
        {"gdscalingcutoff", "required", "member", "gdscalingcutoff", "scalar", "", ""},
        {"gdscalingpeak", "required", "member", "gdscalingpeak", "vector", "MK", ""},
        {"gsync", "required", "", "", "", "", "a pure function of the struct, built per solve by refresh_global_sync(sn) in lang/qn/state_events.h, which includes network_struct.h, so it cannot be a NetworkStruct method"},
        {"hasbreakdown", "required", "method", "hasbreakdown", "vector", "N", ""},
        {"hassetup", "required", "member", "setupparam", "map", "M?", ""},
        {"immfeed", "required", "member", "immfeed", "vector", "MxK", ""},
        {"impatienceClass", "required", "station", "impatience", "vector", "MxK?", ""},
        {"impatienceMu", "required", "station", "patience", "vector", "MxK?", ""},
        {"impatiencePhases", "required", "station", "patience", "vector", "MxK?", ""},
        {"impatiencePhi", "required", "station", "patience", "vector", "MxK?", ""},
        {"impatiencePie", "required", "station", "patience", "vector", "MxK?", ""},
        {"impatienceProc", "required", "station", "patience", "vector", "MxK?", ""},
        {"impatienceType", "required", "station", "patience", "vector", "MxK?", ""},
        {"inchain", "required", "member", "inchain", "vector", "C", ""},
        {"isbasblocking", "required", "member", "isbasblocking", "vector", "N", ""},
        {"isbasdestination", "required", "member", "isbasdestination", "vector", "MxK", ""},
        {"iscatastrophe", "required", "method", "iscatastrophe", "vector", "K", ""},
        {"isfjaugmented", "required", "member", "isfjaugmented", "scalar", "", ""},
        {"isph", "required", "method", "isph", "Matrix", "MxK", ""},
        {"issignal", "required", "member", "issignal", "vector", "K", ""},
        {"isslc", "required", "class", "self_looping", "scalar", "K", ""},
        {"isstatedep", "required", "method", "isstatedep", "Matrix", "Nx3", ""},
        {"isstateful", "required", "node", "stateful", "scalar", "N", ""},
        {"isstation", "required", "node", "station", "scalar", "N", ""},
        {"jdscaling", "required", "station", "jdscaling", "function", "M", ""},
        {"jdscalingpeak", "required", "station", "jdscalingpeak", "vector", "MxK?", ""},
        {"lldscaling", "required", "station", "lldscaling", "vector", "Mx*", ""},
        {"lst", "required", "method", "lst", "vector", "MxK", ""},
        {"markidx", "required", "station", "marked_classes", "vector", "Mx*", ""},
        {"method", "derived", "", "", "", "", "SolverSSA records the method on its options, not on a copy of the struct"},
        {"mu", "required", "method", "mu", "vector", "MxK", ""},
        {"nchains", "required", "member", "nchains", "scalar", "", ""},
        {"nclasses", "required", "member", "nclasses", "scalar", "", ""},
        {"nclosedjobs", "required", "method", "nclosedjobs", "scalar", "", ""},
        {"njobs", "required", "method", "njobs", "vector", "K", ""},
        {"nnodes", "required", "method", "nof_nodes", "scalar", "", ""},
        {"nodenames", "required", "node", "name", "string", "N", ""},
        {"nodeparam", "required", "member", "nodeparam", "map", "N?", ""},
        {"nodeToStateful", "required", "method", "node_to_stateful", "vector", "N", ""},
        {"nodeToStation", "required", "node", "station", "scalar", "N", ""},
        {"nodetype", "required", "node", "nodetype", "scalar", "N", ""},
        {"nodevisits", "required", "member", "nodevisits", "vector", "C", ""},
        {"nregions", "required", "method", "nregions", "scalar", "", ""},
        {"nservers", "required", "station", "nservers", "scalar", "M", ""},
        {"nstateful", "required", "method", "nof_stateful", "scalar", "", ""},
        {"nstations", "required", "member", "nstations", "scalar", "", ""},
        {"nvars", "required", "member", "nvars", "vector", "Nx*", ""},
        {"orbitImpatience", "required", "station", "orbit_impatience", "vector", "MxK?", ""},
        {"orbitMaxJobs", "required", "member", "retrialparam", "map", "M?", ""},
        {"patienceProc", "required", "station", "patience", "vector", "MxK?", ""},
        {"phases", "required", "method", "phases", "Matrix", "MxK", ""},
        {"phaseshift", "required", "method", "phaseshift", "Matrix", "MxK+1", ""},
        {"phasessz", "required", "method", "phasessz", "Matrix", "MxK", ""},
        {"phi", "required", "method", "phi", "vector", "MxK", ""},
        {"pie", "required", "method", "pie", "vector", "MxK", ""},
        {"proc", "required", "member", "service", "vector", "MxK", ""},
        {"procid", "required", "method", "procid", "Matrix", "MxK", ""},
        {"procidDeclared", "derived", "", "", "", "", "not stored: SolverMAM keeps the declared Distrib in service and converts a copy"},
        {"rates", "required", "member", "rates", "Matrix", "MxK", ""},
        {"refclass", "required", "member", "refclass", "vector", "C", ""},
        {"refstat", "required", "class", "refstat", "scalar", "K", ""},
        {"region", "required", "member", "regions", "vector", "R", ""},
        {"regionlincon", "required", "member", "regions", "vector", "R", ""},
        {"regionmaxmem", "required", "member", "regions", "vector", "R", ""},
        {"regionmembers", "required", "member", "regions", "vector", "R", ""},
        {"regionrule", "required", "member", "regions", "vector", "R", ""},
        {"regionsz", "required", "member", "regions", "vector", "R", ""},
        {"regionweight", "required", "member", "regions", "vector", "R", ""},
        {"repairMu", "required", "member", "breakdownparam", "map", "M?", ""},
        {"repairProc", "required", "member", "breakdownparam", "map", "M?", ""},
        {"replyblock", "required", "member", "replyblock", "vector", "NxK", ""},
        {"retrialMaxAttempts", "required", "member", "retrialparam", "map", "M?", ""},
        {"retrialMu", "required", "member", "retrialparam", "map", "M?", ""},
        {"retrialPhi", "required", "member", "retrialparam", "map", "M?", ""},
        {"retrialPolicy", "required", "member", "retrialparam", "map", "M?", ""},
        {"retrialProc", "required", "member", "retrialparam", "map", "M?", ""},
        {"retrialType", "required", "member", "retrialparam", "map", "M?", ""},
        {"reward", "required", "member", "reward", "vector", "*", ""},
        {"routing", "required", "node", "routing", "vector", "NxK?", ""},
        {"rt", "required", "member", "rt", "Matrix", "SKxSK", ""},
        {"rtfun", "required", "", "", "", "", "not stored: state-dependent routing is evaluated by route_eff, rr_dest and the SDR machinery (has_rtfun_routing)"},
        {"rtnodes", "required", "member", "rtnodes", "Matrix", "NKxNK", ""},
        {"rtorig", "required", "member", "P", "map", "KK?", ""},
        {"sched", "required", "station", "sched", "scalar", "M", ""},
        {"schedparam", "required", "station", "schedparam", "vector", "MxK?", ""},
        {"scv", "required", "member", "scv", "Matrix", "MxK", ""},
        {"sdr", "required", "member", "sdr", "opaque", "", ""},
        {"signalremdist", "required", "member", "signalremdist", "vector", "K", ""},
        {"signalrempolicy", "required", "member", "signalrempolicy", "vector", "K", ""},
        {"signaltarget", "required", "member", "signaltarget", "vector", "K", ""},
        {"signaltype", "required", "member", "signaltype", "vector", "K", ""},
        {"space", "required", "member", "statespace", "map", "S?", ""},
        {"state", "required", "member", "initmarking", "map", "S?", ""},
        {"statefulToNode", "required", "member", "stateful_nodes", "vector", "S", ""},
        {"statefulToStation", "required", "method", "stateful_to_station", "vector", "S", ""},
        {"stateprior", "required", "member", "stateprior", "map", "S?", ""},
        {"stationToNode", "required", "member", "station_to_node", "vector", "M", ""},
        {"stationToStateful", "required", "method", "station_to_stateful", "vector", "M", ""},
        {"sync", "required", "", "", "", "", "a pure function of the struct, built per solve by refresh_sync(sn) in lang/qn/state_events.h; that header includes network_struct.h, so the table cannot be a NetworkStruct method, and solver_ctmc_getters rebuilds it on the pool-augmented solved struct rather than reading a stored copy"},
        {"syncreply", "required", "member", "syncreply", "vector", "K", ""},
        {"varsparam", "required", "", "", "", "", "MATLAB only initializes it to -ones(nnodes,1) and no live MATLAB code reads it (its readers are commented out); a cache keeps its item state in nodeparam (CacheParam)"},
        {"visits", "required", "member", "visits", "vector", "C", ""},
    }};
    return fields;
}
 
/** Port-only data members of NetworkStruct (no MATLAB twin), name -> kind. */
inline const std::array<std::array<const char*, 2>, 18>& sn_contract_native() {
    static const std::array<std::array<const char*, 2>, 18> fields = {{
        {{"classes", "vector"}},
        {{"csmatrix", "map"}},
        {{"ctmcpool", "map"}},
        {{"disabled", "vector"}},
        {{"fjjoinparam", "map"}},
        {{"forkparam", "map"}},
        {{"joindecl", "map"}},
        {{"log_path", "string"}},
        {{"name", "string"}},
        {{"nodes", "vector"}},
        {{"pasparam", "map"}},
        {{"Peff", "map"}},
        {{"pollingparam", "map"}},
        {{"sdr_nodes", "opaque"}},
        {{"sinkNode", "scalar"}},
        {{"sourceIdx", "scalar"}},
        {{"stations", "vector"}},
        {{"transparam", "map"}},
    }};
    return fields;
}
 
/**
 * The field view of a struct: one entry per contract field this port stores,
 * keyed by the MATLAB name, plus the dimensions the shapes are written in.
 */
template <class T>
SnFieldViews sn_contract_view(const qn::NetworkStruct<T>& sn) {
    SnFieldViews v;
    v.dims = sn_contract_dims(sn);
    v.fields["arrivalbatch"] = sn_field_rows(sn.stations, [](const decltype(sn.stations[0])& x) { return sn_field_view(x.arrival_batch); });
    v.fields["balkingStrategy"] = sn_field_rows(sn.stations, [](const decltype(sn.stations[0])& x) { return sn_field_view(x.balking); });
    v.fields["balkingThresholds"] = sn_field_rows(sn.stations, [](const decltype(sn.stations[0])& x) { return sn_field_view(x.balking); });
    v.fields["batchRejectProb"] = sn_field_rows(sn.stations, [](const decltype(sn.stations[0])& x) { return sn_field_view(x.batch_reject); });
    v.fields["breakdownMu"] = sn_field_view(sn.breakdownparam);
    v.fields["breakdownProc"] = sn_field_view(sn.breakdownparam);
    v.fields["cap"] = sn_field_view(sn.cap);
    v.fields["cdscaling"] = sn_field_rows(sn.stations, [](const decltype(sn.stations[0])& x) { return sn_field_view(x.cdscaling); });
    v.fields["cdscalingpeak"] = sn_field_rows(sn.stations, [](const decltype(sn.stations[0])& x) { return sn_field_view(x.cdscalingpeak); });
    v.fields["chains"] = sn_field_view(sn.chains);
    v.fields["classcap"] = sn_field_view(sn.classcap);
    v.fields["classdeadline"] = sn_field_rows(sn.classes, [](const decltype(sn.classes[0])& x) { return sn_field_view(x.deadline); });
    v.fields["classnames"] = sn_field_rows(sn.classes, [](const decltype(sn.classes[0])& x) { return sn_field_view(x.name); });
    v.fields["classprio"] = sn_field_rows(sn.classes, [](const decltype(sn.classes[0])& x) { return sn_field_view(x.prio); });
    v.fields["classspawn"] = sn_field_rows(sn.classes, [](const decltype(sn.classes[0])& x) { return sn_field_view(x.spawn); });
    v.fields["connmatrix"] = sn_field_view(sn.connmatrix());
    v.fields["csmask"] = sn_field_view(sn.csmask);
    v.fields["ctmcmapc"] = sn_field_view(sn.ctmcmapc);
    v.fields["downServiceRates"] = sn_field_view(sn.breakdownparam);
    v.fields["droprule"] = sn_field_view(sn.droprule);
    v.fields["fj"] = sn_field_view(sn.fj);
    v.fields["fjauxclass"] = sn_field_view(sn.fjauxclass);
    v.fields["fjclassmap"] = sn_field_view(sn.fjclassmap);
    v.fields["gdscaling"] = sn_field_view(sn.gdscaling);
    v.fields["gdscalingcutoff"] = sn_field_view(sn.gdscalingcutoff);
    v.fields["gdscalingpeak"] = sn_field_view(sn.gdscalingpeak);
    v.fields["hasbreakdown"] = sn_field_view(sn.hasbreakdown());
    v.fields["hassetup"] = sn_field_view(sn.setupparam);
    v.fields["immfeed"] = sn_field_view(sn.immfeed);
    v.fields["impatienceClass"] = sn_field_rows(sn.stations, [](const decltype(sn.stations[0])& x) { return sn_field_view(x.impatience); });
    v.fields["impatienceMu"] = sn_field_rows(sn.stations, [](const decltype(sn.stations[0])& x) { return sn_field_view(x.patience); });
    v.fields["impatiencePhases"] = sn_field_rows(sn.stations, [](const decltype(sn.stations[0])& x) { return sn_field_view(x.patience); });
    v.fields["impatiencePhi"] = sn_field_rows(sn.stations, [](const decltype(sn.stations[0])& x) { return sn_field_view(x.patience); });
    v.fields["impatiencePie"] = sn_field_rows(sn.stations, [](const decltype(sn.stations[0])& x) { return sn_field_view(x.patience); });
    v.fields["impatienceProc"] = sn_field_rows(sn.stations, [](const decltype(sn.stations[0])& x) { return sn_field_view(x.patience); });
    v.fields["impatienceType"] = sn_field_rows(sn.stations, [](const decltype(sn.stations[0])& x) { return sn_field_view(x.patience); });
    v.fields["inchain"] = sn_field_view(sn.inchain);
    v.fields["isbasblocking"] = sn_field_view(sn.isbasblocking);
    v.fields["isbasdestination"] = sn_field_view(sn.isbasdestination);
    v.fields["iscatastrophe"] = sn_field_view(sn.iscatastrophe());
    v.fields["isfjaugmented"] = sn_field_view(sn.isfjaugmented);
    v.fields["isph"] = sn_field_view(sn.isph());
    v.fields["issignal"] = sn_field_view(sn.issignal);
    v.fields["isslc"] = sn_field_rows(sn.classes, [](const decltype(sn.classes[0])& x) { return sn_field_view(x.self_looping); });
    v.fields["isstatedep"] = sn_field_view(sn.isstatedep());
    v.fields["isstateful"] = sn_field_rows(sn.nodes, [](const decltype(sn.nodes[0])& x) { return sn_field_view(x.stateful); });
    v.fields["isstation"] = sn_field_rows(sn.nodes, [](const decltype(sn.nodes[0])& x) { return sn_field_view(x.station); });
    v.fields["jdscaling"] = sn_field_rows(sn.stations, [](const decltype(sn.stations[0])& x) { return sn_field_view(x.jdscaling); });
    v.fields["jdscalingpeak"] = sn_field_rows(sn.stations, [](const decltype(sn.stations[0])& x) { return sn_field_view(x.jdscalingpeak); });
    v.fields["lldscaling"] = sn_field_rows(sn.stations, [](const decltype(sn.stations[0])& x) { return sn_field_view(x.lldscaling); });
    v.fields["lst"] = sn_field_view(sn.lst());
    v.fields["markidx"] = sn_field_rows(sn.stations, [](const decltype(sn.stations[0])& x) { return sn_field_view(x.marked_classes); });
    v.fields["mu"] = sn_field_view(sn.mu());
    v.fields["nchains"] = sn_field_view(sn.nchains);
    v.fields["nclasses"] = sn_field_view(sn.nclasses);
    v.fields["nclosedjobs"] = sn_field_view(sn.nclosedjobs());
    v.fields["njobs"] = sn_field_view(sn.njobs());
    v.fields["nnodes"] = sn_field_view(sn.nof_nodes());
    v.fields["nodenames"] = sn_field_rows(sn.nodes, [](const decltype(sn.nodes[0])& x) { return sn_field_view(x.name); });
    v.fields["nodeparam"] = sn_field_view(sn.nodeparam);
    v.fields["nodeToStateful"] = sn_field_view(sn.node_to_stateful());
    v.fields["nodeToStation"] = sn_field_rows(sn.nodes, [](const decltype(sn.nodes[0])& x) { return sn_field_view(x.station); });
    v.fields["nodetype"] = sn_field_rows(sn.nodes, [](const decltype(sn.nodes[0])& x) { return sn_field_view(x.nodetype); });
    v.fields["nodevisits"] = sn_field_view(sn.nodevisits);
    v.fields["nregions"] = sn_field_view(sn.nregions());
    v.fields["nservers"] = sn_field_rows(sn.stations, [](const decltype(sn.stations[0])& x) { return sn_field_view(x.nservers); });
    v.fields["nstateful"] = sn_field_view(sn.nof_stateful());
    v.fields["nstations"] = sn_field_view(sn.nstations);
    v.fields["nvars"] = sn_field_view(sn.nvars);
    v.fields["orbitImpatience"] = sn_field_rows(sn.stations, [](const decltype(sn.stations[0])& x) { return sn_field_view(x.orbit_impatience); });
    v.fields["orbitMaxJobs"] = sn_field_view(sn.retrialparam);
    v.fields["patienceProc"] = sn_field_rows(sn.stations, [](const decltype(sn.stations[0])& x) { return sn_field_view(x.patience); });
    v.fields["phases"] = sn_field_view(sn.phases());
    v.fields["phaseshift"] = sn_field_view(sn.phaseshift());
    v.fields["phasessz"] = sn_field_view(sn.phasessz());
    v.fields["phi"] = sn_field_view(sn.phi());
    v.fields["pie"] = sn_field_view(sn.pie());
    v.fields["proc"] = sn_field_view(sn.service);
    v.fields["procid"] = sn_field_view(sn.procid());
    v.fields["rates"] = sn_field_view(sn.rates);
    v.fields["refclass"] = sn_field_view(sn.refclass);
    v.fields["refstat"] = sn_field_rows(sn.classes, [](const decltype(sn.classes[0])& x) { return sn_field_view(x.refstat); });
    v.fields["region"] = sn_field_view(sn.regions);
    v.fields["regionlincon"] = sn_field_view(sn.regions);
    v.fields["regionmaxmem"] = sn_field_view(sn.regions);
    v.fields["regionmembers"] = sn_field_view(sn.regions);
    v.fields["regionrule"] = sn_field_view(sn.regions);
    v.fields["regionsz"] = sn_field_view(sn.regions);
    v.fields["regionweight"] = sn_field_view(sn.regions);
    v.fields["repairMu"] = sn_field_view(sn.breakdownparam);
    v.fields["repairProc"] = sn_field_view(sn.breakdownparam);
    v.fields["replyblock"] = sn_field_view(sn.replyblock);
    v.fields["retrialMaxAttempts"] = sn_field_view(sn.retrialparam);
    v.fields["retrialMu"] = sn_field_view(sn.retrialparam);
    v.fields["retrialPhi"] = sn_field_view(sn.retrialparam);
    v.fields["retrialPolicy"] = sn_field_view(sn.retrialparam);
    v.fields["retrialProc"] = sn_field_view(sn.retrialparam);
    v.fields["retrialType"] = sn_field_view(sn.retrialparam);
    v.fields["reward"] = sn_field_view(sn.reward);
    v.fields["routing"] = sn_field_rows(sn.nodes, [](const decltype(sn.nodes[0])& x) { return sn_field_view(x.routing); });
    v.fields["rt"] = sn_field_view(sn.rt);
    v.fields["rtnodes"] = sn_field_view(sn.rtnodes);
    v.fields["rtorig"] = sn_field_view(sn.P);
    v.fields["sched"] = sn_field_rows(sn.stations, [](const decltype(sn.stations[0])& x) { return sn_field_view(x.sched); });
    v.fields["schedparam"] = sn_field_rows(sn.stations, [](const decltype(sn.stations[0])& x) { return sn_field_view(x.schedparam); });
    v.fields["scv"] = sn_field_view(sn.scv);
    v.fields["sdr"] = sn_field_view(sn.sdr);
    v.fields["signalremdist"] = sn_field_view(sn.signalremdist);
    v.fields["signalrempolicy"] = sn_field_view(sn.signalrempolicy);
    v.fields["signaltarget"] = sn_field_view(sn.signaltarget);
    v.fields["signaltype"] = sn_field_view(sn.signaltype);
    v.fields["space"] = sn_field_view(sn.statespace);
    v.fields["state"] = sn_field_view(sn.initmarking);
    v.fields["statefulToNode"] = sn_field_view(sn.stateful_nodes);
    v.fields["statefulToStation"] = sn_field_view(sn.stateful_to_station());
    v.fields["stateprior"] = sn_field_view(sn.stateprior);
    v.fields["stationToNode"] = sn_field_view(sn.station_to_node);
    v.fields["stationToStateful"] = sn_field_view(sn.station_to_stateful());
    v.fields["syncreply"] = sn_field_view(sn.syncreply);
    v.fields["visits"] = sn_field_view(sn.visits);
    return v;
}
 
}  // namespace api
}  // namespace line
 
#endif  // LINE_API_SN_SN_CONTRACT_H